GetOpt.cs

Go to the documentation of this file.

using System;
 
namespace getopt.net {
 
    using System.IO;
    using System.Text.RegularExpressions;
 
    public partial class GetOpt {
 
        public const char MissingArgChar    = '?';
 
        public const char InvalidOptChar    = '!';
 
        public const char NonOptChar        = (char)1;
 
        public const string DoubleDash      = "--";
 
        public const char SingleDash        = '-';
 
        public const char SingleSlash       = '/';
 
        public const char WinArgSeparator   = ':';
 
        public const char GnuArgSeparator   = '=';
 
        public const string ArgSplitRegex   = @"([\s]|[=])";
 
        public const char SingleAtSymbol    = '@';
 
        public Option[] Options { get; set; } = Array.Empty<Option>();
 
        public string? ShortOpts { get; set; } = null;
 
        public bool DoubleDashStopsParsing { get; set; } = true;
 
        private string[] m_appArgs = Array.Empty<string>();
 
        public string[] AppArgs {
            get => m_appArgs;
            set => m_appArgs = value;
        }
 
        public bool OnlyShortOpts { get; set; } = false;
 
        public bool IgnoreEmptyOptions { get; set; } = true;
 
        public bool IgnoreMissingArgument { get; set; } = false;
 
        public bool IgnoreInvalidOptions { get; set; } = true;
 
        public bool IgnoreEmptyAppArgs { get; set; } = true;
 
        public bool StopParsingOptions { get; set; } = false;
 
        public bool AllowWindowsConventions { get; set; } = false;
 
        public bool AllowPowershellConventions { get; set; } = false;
 
        public bool AllowParamFiles { get; set; } = false;
 
        public bool AllExceptionsDisabled {
            get => IgnoreEmptyAppArgs && IgnoreEmptyOptions && IgnoreMissingArgument && IgnoreInvalidOptions && IgnoreEmptyAppArgs;
            set {
                IgnoreEmptyAppArgs = IgnoreEmptyOptions = IgnoreMissingArgument = IgnoreInvalidOptions = IgnoreEmptyAppArgs = value;
            }
        }
 
        public int CurrentIndex => m_currentIndex;
 
        public GetOpt() { }
 
        public GetOpt(string[] appArgs, string shortOpts, params Option[] options) {
            AppArgs = appArgs;
            ShortOpts = shortOpts;
            Options = options;
        }
 
        protected int m_currentIndex = 0;
 
        protected int m_optPosition = 1; // this applies to short opts only, where [0] == '-'
 
#if NET7_0_OR_GREATER
        [GeneratedRegex(ArgSplitRegex, RegexOptions.IgnoreCase | RegexOptions.Compiled)]
        protected static partial Regex ArgumentSplitter();
#else
        protected static Regex ArgumentSplitter() => new(ArgSplitRegex, RegexOptions.IgnoreCase | RegexOptions.Compiled);
#endif
 
        protected void ResetOptPosition() => m_optPosition = 1;
 
        protected bool MustReturnChar1() => ShortOpts?.Length > 0 && ShortOpts[0] == '-';
 
        protected bool MustStopParsing() => ShortOpts?.Length > 0 && ShortOpts[0] == '+' || Environment.GetEnvironmentVariable("POSIXLY_CORRECT") is not null;
 
        public int GetNextOpt(out string? outOptArg) {
            if (AppArgs.Length == 0) {
                if (!IgnoreEmptyAppArgs) {
                    throw new ParseException("No arguments found for parsing!");
                } else {
                    outOptArg = null;
                    return -1;
                }
            }
 
            outOptArg = null; // pre-set this here so we don't have to set it during every condition
 
            if (CurrentIndex >= AppArgs.Length) { return -1; }
 
            if (string.IsNullOrEmpty(AppArgs[m_currentIndex])) {
                if (!IgnoreEmptyOptions) {
                    throw new ParseException("Encountered null or empty argument!");
                } else { return -1; }
            } else if (DoubleDashStopsParsing && AppArgs[CurrentIndex].Equals(DoubleDash, StringComparison.InvariantCultureIgnoreCase)) {
                m_currentIndex++;
                StopParsingOptions = true;
                return GetNextOpt(out outOptArg);
            }
 
            // Check here if StopParsingOptions is true
            // if so, then simply return NonOptChar and set outOptArg to the value of the argument
            if (StopParsingOptions) {
                outOptArg = AppArgs[CurrentIndex];
                m_currentIndex++;
                return NonOptChar;
            }
 
            // Now check if the current argument is a paramfile argument
            if (IsParamFileArg(AppArgs[CurrentIndex], out var paramFile) && paramFile is not null) {
                ReadParamFile(new FileInfo(paramFile));
                m_currentIndex++;
                return GetNextOpt(out outOptArg); // We don't need to pass this back to the application. Instead just continue on
            }
 
            if (IsLongOption(AppArgs[m_currentIndex])) {
                if (Options.Length == 0) { throw new ParseException("Cannot parse long option! No option list provided!"); }
                return ParseLongOption(out outOptArg);
            } else if (IsShortOption(AppArgs[CurrentIndex])) {
                // check if both arg lists are empty
                if (string.IsNullOrEmpty(ShortOpts) && Options.Length == 0) { throw new ParseException("Cannot parse short option! No option list provided!"); }
                return ParseShortOption(out outOptArg);
            }
 
            if (IgnoreInvalidOptions) {
                outOptArg = AppArgs[CurrentIndex];
                m_currentIndex++;
                if (MustReturnChar1()) { return NonOptChar; }
                else { return InvalidOptChar; }
            } else {
                throw new ParseException(AppArgs[CurrentIndex], "Unexpected option argument!");
            }
        }
 
        public CommandOption GetNextOpt() {
            var optChar = GetNextOpt(out var optArg);
 
            if (optArg is null) {
                return new CommandOption(optChar);
            }
 
            if (bool.TryParse(optArg, out bool outBool)) {
                return new CommandOption(optChar, outBool);
            } else if (double.TryParse(optArg, out double outDouble)) {
                return new CommandOption(optChar, outDouble);
            } else if (float.TryParse(optArg, out float outFloat)) {
                return new CommandOption(optChar, outFloat);
            } else if (int.TryParse(optArg, out int outInt)) {
                return new CommandOption(optChar, outInt);
            }
 
            return new CommandOption(optChar, optArg);
        }
 
        protected int ParseLongOption(out string? optArg) {
            if (HasArgumentInOption(out var optName, out optArg)) {
                AppArgs[m_currentIndex] = optName;
            }
 
            AppArgs[m_currentIndex] = StripDashes(true);
 
            var nullableOpt = Options.FindOptionOrDefault(AppArgs[m_currentIndex]);
            if (nullableOpt is null) {
                ++m_currentIndex;
                if (!IgnoreInvalidOptions) {
                    throw new ParseException(AppArgs[m_currentIndex], "Invalid option found!");
                }
 
                optArg = AppArgs[m_currentIndex];
                return InvalidOptChar;
            }
 
            var opt = (Option)nullableOpt;
            switch (opt.ArgumentType) {
                case ArgumentType.Required:
                    if (optArg == null && (IsLongOption(AppArgs[CurrentIndex + 1]) || IsShortOption(AppArgs[CurrentIndex + 1]))) {
                        ++m_currentIndex;
                        if (IgnoreMissingArgument) {
                            return MissingArgChar;
                        } else {
                            throw new ParseException(AppArgs[CurrentIndex], "Missing required argument!");
                        }
                    } else if (optArg != null) { break; }
 
                    optArg = AppArgs[CurrentIndex + 1];
                    if (MustStopParsing()) { // POSIX behaviour desired
                        m_currentIndex = AppArgs.Length;
                        break;
                    }
 
                    ++m_currentIndex;
                    break;
                case ArgumentType.Optional:
                    // DRY this off at some point
                    if (optArg == null && !IsLongOption(AppArgs[CurrentIndex + 1]) && !IsShortOption(AppArgs[CurrentIndex + 1])) {
                        optArg = AppArgs[CurrentIndex + 1];
                        ++m_currentIndex;
                    }
                    break;
                default: // this case will handle cases where developers carelessly cast integers to the enum type
                    optArg = null;
                    break;
            }
 
            ++m_currentIndex;
            return opt.Value;
        }
 
        protected bool TryGetArgumentForShortOption(ref string? arg, out bool incrementCurrentIndex) {
            incrementCurrentIndex = false; // pre-set this
 
            if (m_optPosition + 1 < AppArgs[CurrentIndex].Length) {
                arg = AppArgs[CurrentIndex].Substring(m_optPosition + 1);
                incrementCurrentIndex = true;
                return true;
            }
 
            if (CurrentIndex + 1 >= AppArgs.Length) {
                return false;
            }
 
            if (!IsLongOption(AppArgs[CurrentIndex + 1]) && !IsShortOption(AppArgs[CurrentIndex + 1])) {
                arg = AppArgs[CurrentIndex + 1];
 
                if (MustStopParsing()) {
                    m_currentIndex = AppArgs.Length; // POSIX behaviour desired
                } else {
                    m_currentIndex += 2;
                }
 
                return true;
            }
 
            return false;
        }
 
        protected int ParseShortOption(out string? optArg) {
            optArg = null;
            var curOpt = AppArgs[CurrentIndex][m_optPosition];
 
            bool incrementCurrentIndex = false;
            var argType = ShortOptRequiresArg(curOpt);
            if (argType is null) {
                ResetOptPosition();
                m_currentIndex++;
                return InvalidOptChar;
            } else if (argType is ArgumentType type) {
                switch (type) {
                    default:
                        if (AppArgs[CurrentIndex].Length > AppArgs[CurrentIndex].IndexOf(curOpt) + 1) {
                            m_optPosition++;
                            return curOpt;
                        }
                        break;
                    case ArgumentType.Optional:
                        if (TryGetArgumentForShortOption(ref optArg, out incrementCurrentIndex)) {
                            ResetOptPosition();
                            if (incrementCurrentIndex) { m_currentIndex++; }
                            return curOpt;
                        }
                        break;
                    case ArgumentType.Required:
                        if (!TryGetArgumentForShortOption(ref optArg, out incrementCurrentIndex)) {
                            if (incrementCurrentIndex) { m_currentIndex++; }
                            if (IgnoreMissingArgument) { return MissingArgChar; }
                            else { throw new ParseException(curOpt.ToString(), "Missing argument for option!"); }
                        }
                        break;
                }
            }
 
            ResetOptPosition();
            m_currentIndex++;
 
            return curOpt;
        }
 
        protected ArgumentType? ShortOptRequiresArg(char shortOpt) {
            if (ShortOpts is not null && !string.IsNullOrEmpty(ShortOpts)) {
                var posInStr = ShortOpts.IndexOf(shortOpt);
                if (posInStr == -1) {
                    goto CheckLongOpt;
                }
 
                try {
 
                    char charToCheck;
                    if (posInStr < ShortOpts.Length - 1) {
                        charToCheck = ShortOpts[posInStr + 1];
                    } else {
                        charToCheck = ShortOpts[posInStr];
                    }
 
                    switch (charToCheck) {
                        case ':':
                            return ArgumentType.Required;
                        case ';':
                            return ArgumentType.Optional;
                        default:
                            return ArgumentType.None;
                    }
                } catch {
                    goto CheckLongOpt;
                }
            }
 
        CheckLongOpt:
            if (Options.Length == 0) {
                if (IgnoreInvalidOptions) {
                    return null;
                } else {
                    throw new ParseException(shortOpt.ToString(), "Invalid option list!");
                }
            }
            var nullableOpt = Options.FindOptionOrDefault(shortOpt);
 
            if (nullableOpt == null) {
                if (IgnoreInvalidOptions) {
                    return ArgumentType.None;
                } else { throw new ParseException(shortOpt.ToString(), "Encountered unknown option!"); }
            }
 
            var opt = (Option)nullableOpt;
            return opt.ArgumentType ?? ArgumentType.None;
        }
 
        protected bool HasArgumentInOption(out string optName, out string? argVal) {
            var curArg = AppArgs[CurrentIndex];
            var splitString = default(string[]);
 
            if (AllowWindowsConventions) {
                // if we're allowing Windows conventions, we have to replace
                // the first occurrence of ':' in the arg string with '='
                var indexOfSeparator = curArg.IndexOf(WinArgSeparator);
                if (indexOfSeparator != -1) {
                    curArg = $"{ curArg.Substring(0, indexOfSeparator) }{ GnuArgSeparator }{ curArg.Substring(indexOfSeparator + 1) }";
                }
            }
 
            splitString = ArgumentSplitter().Split(curArg);
 
            if (splitString.Length == 1) {
                optName = StripDashes(true); // we can set this to true, because this method will only ever be called for long opts
                argVal = null;
                return false;
            }
 
            optName = splitString[0];
#if NET6_0_OR_GREATER
            argVal = string.Join("", splitString[2..]);
#else
            argVal = string.Join("", splitString.Skip(2));
#endif
            return true;
        }
 
        protected string StripDashes(bool isLongOpt) {
            var curArg = AppArgs[m_currentIndex];
 
            if (AllowWindowsConventions &&
                curArg.StartsWith(SingleSlash.ToString())) {
                return curArg.Substring(1);
            }
 
            if (!curArg.StartsWith(DoubleDash) &&
                !curArg.StartsWith(SingleDash.ToString())) {
                return curArg;
            }
 
            if (isLongOpt && curArg.StartsWith(DoubleDash)) {
                return curArg.Substring(2);
            } else if (curArg.StartsWith(SingleDash.ToString())) {
                return curArg.Substring(1);
            }
 
            return curArg;
        }
 
        protected static bool ShallStopParsing(ref string arg) {
            return !string.IsNullOrEmpty(arg) &&
                   arg.Equals("--", StringComparison.CurrentCultureIgnoreCase);
        }
 
        protected bool IsLongOption(string arg) {
            if (string.IsNullOrEmpty(arg)) { return false; }
 
            if (
                AllowWindowsConventions &&
                arg.Length > 1          &&
                arg[0] == SingleSlash   &&
                Options.Length != 0     &&
                Options.Any(o => o.Name == arg.Split(WinArgSeparator, GnuArgSeparator, ' ')[0].Substring(1)) // We only need this option when parsing options following Windows' conventions
            ) { return true; }
 
            // Check for Powershell-style arguments.
            // Powershell arguments are weird and extra checks are needed.
            // Powershell-style arguments would theoretically interfere with short opts,
            // so a check to determine whether or not the option is found in Options is required.
            if (
                AllowPowershellConventions  &&
                arg.Length > 1              &&
                arg[0] == SingleDash        &&
                Options.Length != 0         &&
                Options.Any(o => o.Name == arg.Split(WinArgSeparator, GnuArgSeparator, ' ')[0].Substring(1)) // We only need this when parsing options following Powershell's conventions
                // This parsing method is really similar to Windows option parsing...
            ) { return true; }
 
            return arg.Length > 2       &&
                   arg[0] == SingleDash &&
                   arg[1] == SingleDash;
        }
 
        protected bool IsShortOption(string arg) {
            if (string.IsNullOrEmpty(arg)) { return false; }
 
            if (
                AllowWindowsConventions &&
                arg.Length > 1          &&
                arg[0] == SingleSlash   &&
                arg[1] != SingleSlash
            ) { return true; }
 
            return arg.Length > 1       &&
                   arg[0] == SingleDash &&
                   arg[1] != SingleDash;
        }
 
        protected bool IsParamFileArg(string arg, out string? paramFile) {
            paramFile = null; // pre-set this so we don't have to do it everywhere
            if (string.IsNullOrEmpty(arg) || !AllowParamFiles || arg.Length < 2) { return false; }
 
            if (arg[0] != SingleAtSymbol) { return false; }
 
            arg = arg.TrimStart('@');
 
            if (File.Exists(arg)) {
                paramFile = arg;
            }
 
            return true;
        }
 
        protected void ReadParamFile(FileInfo paramFile) {
            if (paramFile == null || !paramFile.Exists) { return; }
 
            var lastIndex = AppArgs.Length;
            var lines = File.ReadAllLines(paramFile.FullName);
            Array.Resize(ref m_appArgs, lines.Length + AppArgs.Length);
 
            for (int i = lastIndex, j = 0; i < m_appArgs.Length && j < lines.Length; i++, j++) {
                if (string.IsNullOrEmpty(lines[j].Trim())) { continue; }
                if (lines[j].Trim()[0] == '#') { continue; }
 
                m_appArgs[i] = lines[j];
            }
        }
    }
}