GetOpt-like class for handling getopt-like command-line arguments in .net. More...

Public Member Functions
	GetOpt ()
	Default constructor; it is recommended to use this constructor and to use brace-initialiser-lists to instantiate/configure each instance of this object. More...

	GetOpt (string[] appArgs, string shortOpts, params Option[] options)
	Specialised constructor. More...

int	GetNextOpt (out string? outOptArg)
	Gets the next option in the list. More...

CommandOption	GetNextOpt ()
	Gets the next option in the list, returning an object containing more detailled information about the option. More...

Static Public Attributes
const char	MissingArgChar = '?'
	The character that is returned when an option is missing a required argument. More...

const char	InvalidOptChar = '!'
	The character that is returned when an invalid option is returned. More...

const char	NonOptChar = (char)1
	The character that is returned when a non-option value is encountered and it is not the argument to an option. More...

const string	DoubleDash = "--"
	This is the string getopt.net looks for when DoubleDashStopsParsing is enabled. More...

const char	SingleDash = '-'
	A single dash character. This is the character that is searched for, when parsing POSIX-/GNU-like options. More...

const char	SingleSlash = '/'
	A single slash. This is the char that is searched for when parsing arguments with the Windows convention. More...

const char	WinArgSeparator = ':'
	The argument separator used by Windows. More...

const char	GnuArgSeparator = '='
	The argument separator used by POSIX / GNU getopt. More...

const string	ArgSplitRegex = @"([\s]\|[=])"
	The regex used by ArgumentSplitter to split arguments into a key-value pair. More...

const char	SingleAtSymbol = '@'
	A single "at" character. This character is used when AllowParamFiles is enabled, to determine whether or not a param file has been passed to getopt.net. More...

Protected Member Functions
void	ResetOptPosition ()
	Resets the option position to 1. More...

bool	MustReturnChar1 ()
	Gets a value indicating whether or not non-options should be handled as if they were the argument of an option with the character code 1. More...

bool	MustStopParsing ()
	If the first character of ShortOpts is '+' or the environment variable POSIXLY_CORRECT is set, then option processing stops as soon as a nonoption argument is encountered. More...

int	ParseLongOption (out string? optArg)
	Parses long options More...

bool	TryGetArgumentForShortOption (ref string? arg, out bool incrementCurrentIndex)
	Attempts to retrieve the argument for the current short option. More...

int	ParseShortOption (out string? optArg)
	Parses a single short option. More...

ArgumentType?	ShortOptRequiresArg (char shortOpt)
	Gets a value indicating whether or not a short option requires an argument. More...

bool	HasArgumentInOption (out string optName, out string? argVal)
	Determines whether or not the current option contains its argument with the string or not. More...

string	StripDashes (bool isLongOpt)
	Strips leading dashes from strings. More...

bool	ShallStopParsing (ref string arg)
	Gets a value indicating whether or not the parser shall stop here. More...

bool	IsLongOption (string arg)
	Gets a value indicating whether or not the current string is a long option. More...

bool	IsShortOption (string arg)
	Gets a value indicating whether or not the current string is/contains a (or more) short option More...

bool	IsParamFileArg (string arg, out string? paramFile)
	Gets a value indicating whether or not a given option is a paramfile option. AllowParamFiles. More...

void	ReadParamFile (FileInfo paramFile)
	Reads the incoming param file and adds the contents to AppArgs More...

Static Protected Member Functions
static Regex	ArgumentSplitter ()
	Compiled Regex. More...

Protected Attributes
int	m_currentIndex = 0
	The current index while traversing AppArgs More...

int	m_optPosition = 1
	The current position in a multi-option string such as "-xvzRf" when parsing short options. More...

Properties
Option[]	Options = Array.Empty<Option>() `[get, set]`
	An optional list of long options to go with the short options. More...

string?	ShortOpts = null `[get, set]`
	The short opts to use. More...

bool	DoubleDashStopsParsing = true `[get, set]`
	Gets or sets a value indicating whether or not "--" stops parsing. Default: More...

string[]	AppArgs `[get, set]`
	Gets or sets the arguments to parse. More...

bool	OnlyShortOpts = false `[get, set]`
	Gets or sets a value indicating whether or not to only parse short options. Default: More...

bool	IgnoreEmptyOptions = true `[get, set]`
	Gets or sets a value indicating whether or not to ignore empty values. Default: More...

bool	IgnoreMissingArgument = false `[get, set]`
	Gets or sets a value indicating whether or not to ignore missing arguments. Default: More...

bool	IgnoreInvalidOptions = true `[get, set]`
	Gets or sets a value indicating whether or not invalid arguments should be ignored or not. Default: More...

bool	IgnoreEmptyAppArgs = true `[get, set]`
	Gets or sets a value indicating whether or not empty AppArgs are ignored or throw an exception. Default: More...

bool	StopParsingOptions = false `[get, set]`
	Gets or sets a value indicating whether or not option parsing shall stop or not. Default: More...

bool	AllowWindowsConventions = false `[get, set]`
	Gets or sets a value indicating whether or not Windows argument conventions are allowed. Default: More...

bool	AllowPowershellConventions = false `[get, set]`
	Gets or sets a value indicating whether or not Powershell-style arguments are allowed. This option doesn't conflict with the GNU/POSIX or Windows-style argument parsing and is simply an addition. More...

bool	AllowParamFiles = false `[get, set]`
	Gets or sets a value indicating whether or not parameter files are accepted as a valid form of input. More...

bool	AllExceptionsDisabled `[get, set]`
	Either enables or disabled exceptions entirely. For more specific control over exceptions, see the other options provided by GetOpt. More...

int	CurrentIndex `[get]`
	Gets the current index of the app arguments being parsed. More...

Private Attributes
string[]	m_appArgs = Array.Empty<string>()

Detailed Description

GetOpt-like class for handling getopt-like command-line arguments in .net.

This class contains all the properties and logic required for parsing getopt-like command-line arguments.

A detailled description of the usage of this class can be found in the .

Definition at line 15 of file GetOpt.cs.

Constructor & Destructor Documentation

◆ GetOpt() [1/2]

getopt.net.GetOpt.GetOpt ( )

inline

Default constructor; it is recommended to use this constructor and to use brace-initialiser-lists to instantiate/configure each instance of this object.

Definition at line 202 of file GetOpt.cs.

202{ }

◆ GetOpt() [2/2]

getopt.net.GetOpt.GetOpt	(	string[]	appArgs,
		string	shortOpts,
		params Option[]	options
	)

inline

Specialised constructor.

Parameters

appArgs	The arguments passed to the application.
shortOpts
options

Definition at line 210 of file GetOpt.cs.

                                                                                   {
            AppArgs = appArgs;
            ShortOpts = shortOpts;
            Options = options;
        }

References getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.Options, and getopt.net.GetOpt.ShortOpts.

Member Function Documentation

◆ ArgumentSplitter()

static Regex getopt.net.GetOpt.ArgumentSplitter ( )

staticprotected

Compiled Regex.

Returns: A pre-compiled and optimised regular expression object.

Referenced by getopt.net.GetOpt.HasArgumentInOption().

◆ GetNextOpt() [1/2]

CommandOption getopt.net.GetOpt.GetNextOpt ( )

inline

Gets the next option in the list, returning an object containing more detailled information about the option.

Returns: An instance of CommandOption containing more detailled information about the option and argument (if applicable).

Definition at line 334 of file GetOpt.cs.

                                          {
            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);
        }

References getopt.net.GetOpt.GetNextOpt().

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ GetNextOpt() [2/2]

int getopt.net.GetOpt.GetNextOpt ( out string? outOptArg )

inline

Gets the next option in the list.

Parameters

outOptArg Out var; the argument for the option (if applicable).

Returns: The next option.

Exceptions

ParseException If ignoring errors is disabled (default) and an error occurs.

Definition at line 272 of file GetOpt.cs.

                                                     {
            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 0; }
            } 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!");
            }
        }

◆ HasArgumentInOption()

bool getopt.net.GetOpt.HasArgumentInOption	(	out string	optName,
		out string?	argVal
	)

inlineprotected

Determines whether or not the current option contains its argument with the string or not.

Parameters

optName	Out var; the name of the option
argVal	Out var; the value of the argument

Returns: true

if the option contains its argument.
false

otherwise.

Definition at line 564 of file GetOpt.cs.

                                                                                   {
            var curArg = AppArgs[CurrentIndex];
            var splitString = Array.Empty<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;
        }

References getopt.net.GetOpt.AllowWindowsConventions, getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.ArgumentSplitter(), getopt.net.GetOpt.CurrentIndex, getopt.net.GetOpt.StripDashes(), and getopt.net.GetOpt.WinArgSeparator.

Referenced by getopt.net.GetOpt.ParseLongOption().

◆ IsLongOption()

bool getopt.net.GetOpt.IsLongOption ( string arg )

inlineprotected

Gets a value indicating whether or not the current string is a long option.

Parameters

arg	The string to check.

Returns: true

if the passed string is a long option.

Definition at line 639 of file GetOpt.cs.

                                                {
            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, ' ').First().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, ' ').First().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;
        }

References getopt.net.GetOpt.AllowPowershellConventions, getopt.net.GetOpt.AllowWindowsConventions, getopt.net.GetOpt.GnuArgSeparator, getopt.net.GetOpt.Options, getopt.net.GetOpt.SingleDash, getopt.net.GetOpt.SingleSlash, and getopt.net.GetOpt.WinArgSeparator.

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ IsParamFileArg()

bool getopt.net.GetOpt.IsParamFileArg	(	string	arg,
		out string?	paramFile
	)

inlineprotected

Gets a value indicating whether or not a given option is a paramfile option. AllowParamFiles.

If arg is a valid paramfile option, but the file doesn't exist, paramFile will be set to

null

. Otherwise, paramFile will be set to the path to the file.

Parameters

arg	The argument to check.
paramFile	An out param containing either null or the path to the file.

Returns: true

if the passed argument is a valid paramfile option.
false

otherwise.

Definition at line 699 of file GetOpt.cs.

                                                                         {
            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;
        }

References getopt.net.GetOpt.AllowParamFiles, and getopt.net.GetOpt.SingleAtSymbol.

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ IsShortOption()

bool getopt.net.GetOpt.IsShortOption ( string arg )

inlineprotected

Gets a value indicating whether or not the current string is/contains a (or more) short option

Parameters

arg	The string to check.

Returns: true

if the string contains one or more short options

Definition at line 673 of file GetOpt.cs.

                                                 {
            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;
        }

References getopt.net.GetOpt.AllowWindowsConventions, getopt.net.GetOpt.SingleDash, and getopt.net.GetOpt.SingleSlash.

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ MustReturnChar1()

bool getopt.net.GetOpt.MustReturnChar1 ( )

protected

Gets a value indicating whether or not non-options should be handled as if they were the argument of an option with the character code 1.

From the getopt man page:

‍If the first character of optstring is '-', then each nonoption argv-element is handled as if it were the argument of an option with character code 1. (This is used by programs that were written to expect options and other argv-elements in any order and that care about the ordering of the two.)

Returns

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ MustStopParsing()

bool getopt.net.GetOpt.MustStopParsing ( )

protected

If the first character of ShortOpts is '+' or the environment variable POSIXLY_CORRECT is set, then option processing stops as soon as a nonoption argument is encountered.

Returns: true

if parsing stops when the first non-option string is found.

Referenced by getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ ParseLongOption()

int getopt.net.GetOpt.ParseLongOption ( out string? optArg )

inlineprotected

Parses long options

Parameters

optArg Out var; the option's argument (if applicable)

Returns: If the option was found and no (ignored) errors were detected, the Option.Value of the argument. If an invalid option was found, '!' is returned. If a required argument is missing, '?' is returned.

Exceptions

ParseException If ignoring of errors is disabled and a parsing error occurs.

Definition at line 364 of file GetOpt.cs.

                                                          {
            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!");
                }
 
                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.None:
                default: // this case will handle cases where developers carelessly cast integers to the enum type
                    optArg = null;
                    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;
            }
 
            ++m_currentIndex;
            return opt.Value;
        }

References getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.CurrentIndex, getopt.net.GetOpt.HasArgumentInOption(), getopt.net.GetOpt.IgnoreInvalidOptions, getopt.net.GetOpt.IgnoreMissingArgument, getopt.net.GetOpt.InvalidOptChar, getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.IsShortOption(), getopt.net.GetOpt.m_currentIndex, getopt.net.GetOpt.MissingArgChar, getopt.net.GetOpt.MustStopParsing(), getopt.net.GetOpt.Options, and getopt.net.GetOpt.StripDashes().

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ ParseShortOption()

int getopt.net.GetOpt.ParseShortOption ( out string? optArg )

inlineprotected

Parses a single short option.

Parameters

optArg Out var; the argument required for the option.

Returns: The current option value.

Exceptions

ParseException If ignoring of errors is disabled (default) will throw a ParseException if an error occurs.

Definition at line 460 of file GetOpt.cs.

                                                           {
            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:
                    case ArgumentType.None:
                        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;
        }

References getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.CurrentIndex, getopt.net.GetOpt.IgnoreMissingArgument, getopt.net.GetOpt.InvalidOptChar, getopt.net.GetOpt.m_currentIndex, getopt.net.GetOpt.m_optPosition, getopt.net.GetOpt.MissingArgChar, getopt.net.GetOpt.ResetOptPosition(), getopt.net.GetOpt.ShortOptRequiresArg(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ ReadParamFile()

void getopt.net.GetOpt.ReadParamFile ( FileInfo paramFile )

inlineprotected

Reads the incoming param file and adds the contents to AppArgs

Parameters

paramFile The file to read.

Definition at line 718 of file GetOpt.cs.

                                                         {
            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];
            }
        }

References getopt.net.GetOpt.AppArgs, and getopt.net.GetOpt.m_appArgs.

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ ResetOptPosition()

void getopt.net.GetOpt.ResetOptPosition ( )

protected

Resets the option position to 1.

Referenced by getopt.net.GetOpt.ParseShortOption().

◆ ShallStopParsing()

bool getopt.net.GetOpt.ShallStopParsing ( ref string arg )

inlineprotected

Gets a value indicating whether or not the parser shall stop here.

Parameters

arg	The arg to check

Returns: true

if the parser shall stop parsing.
false

otherwise.

Definition at line 629 of file GetOpt.cs.

                                                        {
            return !string.IsNullOrEmpty(arg) &&
                   arg.Equals("--", StringComparison.CurrentCultureIgnoreCase);
        }

◆ ShortOptRequiresArg()

ArgumentType? getopt.net.GetOpt.ShortOptRequiresArg ( char shortOpt )

inlineprotected

Gets a value indicating whether or not a short option requires an argument.

Parameters

shortOpt The opt to check for.

Returns: true

if the short opt requires an argument.

Exceptions

ParseException If ignoring errors is disabled (default) and an error occurs during parsing.

Definition at line 508 of file GetOpt.cs.

                                                                   {
            if (!string.IsNullOrEmpty(ShortOpts) && ShortOpts is not null) {
                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) {
                    shortOpt = InvalidOptChar;
                    return ArgumentType.None;
                } else { throw new ParseException(shortOpt.ToString(), "Encountered unknown option!"); }
            }
 
            var opt = (Option)nullableOpt;
            return opt.ArgumentType ?? ArgumentType.None;
        }

References getopt.net.GetOpt.IgnoreInvalidOptions, getopt.net.GetOpt.InvalidOptChar, getopt.net.GetOpt.Options, and getopt.net.GetOpt.ShortOpts.

Referenced by getopt.net.GetOpt.ParseShortOption().

◆ StripDashes()

string getopt.net.GetOpt.StripDashes ( bool isLongOpt )

inlineprotected

Strips leading dashes from strings.

If AllowWindowsConventions is enabled, then this method will also strip leading slashes!

Parameters

isLongOpt Whether or not the current option is a long option.

Returns: The stripped string

Definition at line 602 of file GetOpt.cs.

                                                     {
            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;
        }

References getopt.net.GetOpt.AllowWindowsConventions, getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.DoubleDash, getopt.net.GetOpt.m_currentIndex, getopt.net.GetOpt.SingleDash, and getopt.net.GetOpt.SingleSlash.

Referenced by getopt.net.GetOpt.HasArgumentInOption(), and getopt.net.GetOpt.ParseLongOption().

◆ TryGetArgumentForShortOption()

bool getopt.net.GetOpt.TryGetArgumentForShortOption	(	ref string?	arg,
		out bool	incrementCurrentIndex
	)

inlineprotected

Attempts to retrieve the argument for the current short option.

This is only a helper method to keep the code cleaner.

Parameters

arg	A reference to the current optArg parameter in ParseShortOption(out string?)
incrementCurrentIndex	Whether or not to increment m_currentIndex

Returns: true

if an argument was found for the current option.
false

otherwise.

Definition at line 426 of file GetOpt.cs.

                                                                                                     {
            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;
        }

References getopt.net.GetOpt.AppArgs, getopt.net.GetOpt.CurrentIndex, getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.IsShortOption(), getopt.net.GetOpt.m_currentIndex, getopt.net.GetOpt.m_optPosition, and getopt.net.GetOpt.MustStopParsing().

Referenced by getopt.net.GetOpt.ParseShortOption().

Member Data Documentation

◆ ArgSplitRegex

const string getopt.net.GetOpt.ArgSplitRegex = @"([\s]|[=])"

static

The regex used by ArgumentSplitter to split arguments into a key-value pair.

Definition at line 62 of file GetOpt.cs.

◆ DoubleDash

const string getopt.net.GetOpt.DoubleDash = "--"

static

This is the string getopt.net looks for when DoubleDashStopsParsing is enabled.

Definition at line 35 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.GetNextOpt(), and getopt.net.GetOpt.StripDashes().

◆ GnuArgSeparator

const char getopt.net.GetOpt.GnuArgSeparator = '='

static

The argument separator used by POSIX / GNU getopt.

Definition at line 57 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.IsLongOption().

◆ InvalidOptChar

const char getopt.net.GetOpt.InvalidOptChar = '!'

static

The character that is returned when an invalid option is returned.

Definition at line 25 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.ParseLongOption(), getopt.net.GetOpt.ParseShortOption(), and getopt.net.GetOpt.ShortOptRequiresArg().

◆ m_appArgs

string [] getopt.net.GetOpt.m_appArgs = Array.Empty<string>()

private

Definition at line 86 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.ReadParamFile().

◆ m_currentIndex

int getopt.net.GetOpt.m_currentIndex = 0

protected

The current index while traversing AppArgs

Definition at line 219 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.ParseLongOption(), getopt.net.GetOpt.ParseShortOption(), getopt.net.GetOpt.StripDashes(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ m_optPosition

int getopt.net.GetOpt.m_optPosition = 1

protected

The current position in a multi-option string such as "-xvzRf" when parsing short options.

Definition at line 224 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.ParseShortOption(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ MissingArgChar

const char getopt.net.GetOpt.MissingArgChar = '?'

static

The character that is returned when an option is missing a required argument.

Definition at line 20 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.ParseShortOption().

◆ NonOptChar

const char getopt.net.GetOpt.NonOptChar = (char)1

static

The character that is returned when a non-option value is encountered and it is not the argument to an option.

Definition at line 30 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ SingleAtSymbol

const char getopt.net.GetOpt.SingleAtSymbol = '@'

static

A single "at" character. This character is used when AllowParamFiles is enabled, to determine whether or not a param file has been passed to getopt.net.

Definition at line 68 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.IsParamFileArg().

◆ SingleDash

const char getopt.net.GetOpt.SingleDash = '-'

static

A single dash character. This is the character that is searched for, when parsing POSIX-/GNU-like options.

Definition at line 41 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.IsShortOption(), and getopt.net.GetOpt.StripDashes().

◆ SingleSlash

const char getopt.net.GetOpt.SingleSlash = '/'

static

A single slash. This is the char that is searched for when parsing arguments with the Windows convention.

Definition at line 47 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.IsShortOption(), and getopt.net.GetOpt.StripDashes().

◆ WinArgSeparator

const char getopt.net.GetOpt.WinArgSeparator = ':'

static

The argument separator used by Windows.

Definition at line 52 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.HasArgumentInOption(), and getopt.net.GetOpt.IsLongOption().

Property Documentation

◆ AllExceptionsDisabled

bool getopt.net.GetOpt.AllExceptionsDisabled

getset

Either enables or disabled exceptions entirely. For more specific control over exceptions, see the other options provided by GetOpt.

true if exceptions are enabled, false otherwise.

Definition at line 186 of file GetOpt.cs.

                                          {
            get => IgnoreEmptyAppArgs && IgnoreEmptyOptions && IgnoreMissingArgument && IgnoreInvalidOptions && IgnoreEmptyAppArgs;
            set {
                IgnoreEmptyAppArgs = IgnoreEmptyOptions = IgnoreMissingArgument = IgnoreInvalidOptions = IgnoreEmptyAppArgs = value;
            }
        }

◆ AllowParamFiles

bool getopt.net.GetOpt.AllowParamFiles = false

getset

Gets or sets a value indicating whether or not parameter files are accepted as a valid form of input.

Parameter files are known from some software, such as GCC. A param file can be passed as @/path/to/file.

Param files must follow certain rules, in order to be accepted by getopt.net.

Param files MUST be text files, the file ending doesn't matter.
The contents of the file MUST be split by
(newlines).
each line must be an argument acceptable by getopt.net, depending on the options set.
- i.e. to accept Windows-convention arguments, AllowWindowsConventions must be enabled
- to accept Powershell-convention arguments, AllowPowershellConventions must be enabled
paramfile arguments (@/path/to/file) may be added in addition to any other arguments!

Definition at line 178 of file GetOpt.cs.

178{ get; set; } = false;

Referenced by getopt.net.GetOpt.IsParamFileArg().

◆ AllowPowershellConventions

bool getopt.net.GetOpt.AllowPowershellConventions = false

getset

Gets or sets a value indicating whether or not Powershell-style arguments are allowed. This option doesn't conflict with the GNU/POSIX or Windows-style argument parsing and is simply an addition.

This option is disabled by default.

Powershell-style arguments are similar to GNU/POSIX long options, however they begin with a single dash (-).

Definition at line 160 of file GetOpt.cs.

160{ get; set; } = false;

Referenced by getopt.net.GetOpt.IsLongOption().

◆ AllowWindowsConventions

bool getopt.net.GetOpt.AllowWindowsConventions = false

getset

Gets or sets a value indicating whether or not Windows argument conventions are allowed. Default:

false

By convention, Windows-like options begin with a slash (/). Options with arguments are separated by a colon ':'.

Definition at line 149 of file GetOpt.cs.

149{ get; set; } = false;

Referenced by getopt.net.GetOpt.HasArgumentInOption(), getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.IsShortOption(), and getopt.net.GetOpt.StripDashes().

◆ AppArgs

string [] getopt.net.GetOpt.AppArgs

getset

Gets or sets the arguments to parse.

Definition at line 91 of file GetOpt.cs.

                                {
            get => m_appArgs;
            set => m_appArgs = value;
        }

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.GetOpt(), getopt.net.GetOpt.HasArgumentInOption(), getopt.net.GetOpt.ParseLongOption(), getopt.net.GetOpt.ParseShortOption(), getopt.net.GetOpt.ReadParamFile(), getopt.net.GetOpt.StripDashes(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ CurrentIndex

int getopt.net.GetOpt.CurrentIndex

get

Gets the current index of the app arguments being parsed.

Definition at line 196 of file GetOpt.cs.

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.HasArgumentInOption(), getopt.net.GetOpt.ParseLongOption(), getopt.net.GetOpt.ParseShortOption(), and getopt.net.GetOpt.TryGetArgumentForShortOption().

◆ DoubleDashStopsParsing

bool getopt.net.GetOpt.DoubleDashStopsParsing = true

getset

Gets or sets a value indicating whether or not "--" stops parsing. Default:

true

Definition at line 84 of file GetOpt.cs.

84{ get; set; } = true;

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ IgnoreEmptyAppArgs

bool getopt.net.GetOpt.IgnoreEmptyAppArgs = true

getset

Gets or sets a value indicating whether or not empty AppArgs are ignored or throw an exception. Default:

true

Definition at line 130 of file GetOpt.cs.

130{ get; set; } = true;

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ IgnoreEmptyOptions

bool getopt.net.GetOpt.IgnoreEmptyOptions = true

getset

Gets or sets a value indicating whether or not to ignore empty values. Default:

true

Definition at line 106 of file GetOpt.cs.

106{ get; set; } = true;

Referenced by getopt.net.GetOpt.GetNextOpt().

◆ IgnoreInvalidOptions

bool getopt.net.GetOpt.IgnoreInvalidOptions = true

getset

Gets or sets a value indicating whether or not invalid arguments should be ignored or not. Default:

true

If this is set to

true

and an invalid argument is found, then '!' will be returned.

Definition at line 124 of file GetOpt.cs.

124{ get; set; } = true;

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.ShortOptRequiresArg().

◆ IgnoreMissingArgument

bool getopt.net.GetOpt.IgnoreMissingArgument = false

getset

Gets or sets a value indicating whether or not to ignore missing arguments. Default:

false

If this is set to

true

and a required argument is missing, '?' will be returned.

Definition at line 115 of file GetOpt.cs.

115{ get; set; } = false;

Referenced by getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.ParseShortOption().

◆ OnlyShortOpts

bool getopt.net.GetOpt.OnlyShortOpts = false

getset

Gets or sets a value indicating whether or not to only parse short options. Default:

false

Definition at line 100 of file GetOpt.cs.

100{ get; set; } = false;

◆ Options

Option [] getopt.net.GetOpt.Options = Array.Empty<Option>()

getset

An optional list of long options to go with the short options.

Definition at line 73 of file GetOpt.cs.

73{ get; set; } = Array.Empty<Option>();

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.GetOpt(), getopt.net.GetOpt.IsLongOption(), getopt.net.GetOpt.ParseLongOption(), and getopt.net.GetOpt.ShortOptRequiresArg().

◆ ShortOpts

string? getopt.net.GetOpt.ShortOpts = null

getset

The short opts to use.

Definition at line 78 of file GetOpt.cs.

78{ get; set; } = null;

Referenced by getopt.net.GetOpt.GetNextOpt(), getopt.net.GetOpt.GetOpt(), and getopt.net.GetOpt.ShortOptRequiresArg().

◆ StopParsingOptions

bool getopt.net.GetOpt.StopParsingOptions = false

getset

Gets or sets a value indicating whether or not option parsing shall stop or not. Default:

false

When this is set to

true

, all remaining arguments in AppArgs will be returned without being parsed.

Definition at line 139 of file GetOpt.cs.

139{ get; set; } = false;

Referenced by getopt.net.GetOpt.GetNextOpt().

The documentation for this class was generated from the following file:

GetOpt.cs

Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Properties

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GetOpt() [1/2]

◆ GetOpt() [2/2]

Member Function Documentation

◆ ArgumentSplitter()

◆ GetNextOpt() [1/2]

◆ GetNextOpt() [2/2]

◆ HasArgumentInOption()

◆ IsLongOption()

◆ IsParamFileArg()

◆ IsShortOption()

◆ MustReturnChar1()

◆ MustStopParsing()

◆ ParseLongOption()

◆ ParseShortOption()

◆ ReadParamFile()

◆ ResetOptPosition()

◆ ShallStopParsing()

◆ ShortOptRequiresArg()

◆ StripDashes()

◆ TryGetArgumentForShortOption()

Member Data Documentation

◆ ArgSplitRegex

◆ DoubleDash

◆ GnuArgSeparator

◆ InvalidOptChar

◆ m_appArgs

◆ m_currentIndex

◆ m_optPosition

◆ MissingArgChar

◆ NonOptChar

◆ SingleAtSymbol

◆ SingleDash

◆ SingleSlash

◆ WinArgSeparator

Property Documentation

◆ AllExceptionsDisabled

◆ AllowParamFiles

◆ AllowPowershellConventions

◆ AllowWindowsConventions

◆ AppArgs

◆ CurrentIndex

◆ DoubleDashStopsParsing

◆ IgnoreEmptyAppArgs

◆ IgnoreEmptyOptions

◆ IgnoreInvalidOptions

◆ IgnoreMissingArgument

◆ OnlyShortOpts

◆ Options

◆ ShortOpts

◆ StopParsingOptions