private Regex BuildRegEx(OptStyle optStyle, UnixShortOption unixShortOption)
{
if (optStyle == OptStyle.Unix)
{
return(new Regex(@"^
(?:
--(?<longname>[^\s=]+)
(?<longvalue>=.+)?
|
-(?<shortname>\S)
(?<shortvalue>.+)?
)$" , RegexOptions.IgnorePatternWhitespace));
}
else
{
return(new Regex(@"^/(?<longname>[^\s:]+)(?<longvalue>:.+)?$"));
}
}
private Regex BuildRegEx(OptStyle optStyle, UnixShortOption unixShortOption)
{
if (optStyle == OptStyle.Unix)
return new Regex(@"^
(?:
--(?<longname>[^\s=]+)
(?<longvalue>=.+)?
|
-(?<shortname>\S)
(?<shortvalue>.+)?
)$", RegexOptions.IgnorePatternWhitespace);
else
return new Regex(@"^/(?<longname>[^\s:]+)(?<longvalue>:.+)?$");
}
/// <summary>
/// Parse the arguments for options using the given settings
/// </summary>
/// <param name="optStyle">What type of options to parse</param>
/// <param name="unixShortOption">How to parse unix short options (ignored
/// if not unix style parsing)</param>
/// <param name="dupOptHandleType">How to handle un-expected duplicate option
/// definitions</param>
/// <param name="unknownOptHandleType">How to handle options that were not
/// defined</param>
/// <param name="caseSesitive">If the parsing of options
/// should consider the case of the options</param>
/// <param name="args">The command-line arguments to parse</param>
/// <returns>Arguments from the command-line that were not options</returns>
public string[] Parse(OptStyle optStyle, UnixShortOption unixShortOption,
DupOptHandleType dupOptHandleType, UnknownOptHandleType unknownOptHandleType,
bool caseSesitive, string[] args)
{
ArrayList foundDefinitions = new ArrayList();
Group grp;
Match m;
Regex re;
StringCollection arguments;
bool isShort;
bool unknown;
string name;
string value;
string[] results;
if (args == null || args.Length == 0)
{
if (this.SearchEnvironment)
{
ParseEnvironment(foundDefinitions, caseSesitive);
}
return(new string[0]);
}
arguments = new StringCollection();
re = BuildRegEx(optStyle, unixShortOption);
for (int i = 0; i < args.Length; i++)
{
m = re.Match(args[i]);
if (m.Success)
{
// see if there is a value
grp = m.Groups["shortname"];
if (grp != null && grp.Value != string.Empty)
{
isShort = true;
name = grp.Value;
value = m.Groups["shortvalue"].Value;
}
else
{
isShort = false;
name = m.Groups["longname"].Value;
value = m.Groups["longvalue"].Value;
// remove the '=' or ':' at the beginning of the value
if (value != null && value.Length > 0)
{
value = value.Substring(1);
}
}
if (optStyle == OptStyle.Unix)
{
if (isShort == false)
{
ParseLongOption(args, name, value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
// see if the value is just concatinated short options
else if (unixShortOption == UnixShortOption.CollapseShort)
{
// name is the first option
ParseShortOption(args, name[0], null, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
// parse the rest of the options that lie in the 'value' variable
if (value != null)
{
char[] unknownOptions;
ParseShortOptions(args, value.ToLower().ToCharArray(),
caseSesitive, ref i, dupOptHandleType, unknownOptHandleType,
foundDefinitions, out unknownOptions);
// don't do anything with unknown concatinated short options,
// they should not be considered options or arguments
}
}
else
{
// name is the first option
ParseShortOption(args, name[0], value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
}
else
{
if (name.Length == 1)
{
ParseShortOption(args, name[0], value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
else
{
ParseLongOption(args, name, value, caseSesitive, ref i,
dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
}
// consider unknown options to be arguments
if (unknown)
{
arguments.Add(args[i]);
}
}
else
{
arguments.Add(args[i]);
}
}
// parse the environment
if (this.SearchEnvironment)
{
ParseEnvironment(foundDefinitions, caseSesitive);
}
results = new string[arguments.Count];
arguments.CopyTo(results, 0);
return(results);
}
/// <summary>
/// Parse the arguments for options using the given settings
/// </summary>
/// <param name="optStyle">What type of options to parse</param>
/// <param name="unixShortOption">How to parse unix short options (ignored
/// if not unix style parsing)</param>
/// <param name="dupOptHandleType">How to handle un-expected duplicate option
/// definitions</param>
/// <param name="unknownOptHandleType">How to handle options that were not
/// defined</param>
/// <param name="caseSesitive">If the parsing of options
/// should consider the case of the options</param>
/// <param name="args">The command-line arguments to parse</param>
/// <returns>Arguments from the command-line that were not options</returns>
public string[] Parse(OptStyle optStyle, UnixShortOption unixShortOption,
DupOptHandleType dupOptHandleType, UnknownOptHandleType unknownOptHandleType,
bool caseSesitive, string[] args)
{
ArrayList foundDefinitions = new ArrayList();
Group grp;
Match m;
Regex re;
StringCollection arguments;
bool isShort;
bool unknown;
string name;
string value;
string[] results;
if (args == null || args.Length == 0)
{
if (this.SearchEnvironment)
ParseEnvironment(foundDefinitions, caseSesitive);
return new string[0];
}
arguments = new StringCollection();
re = BuildRegEx(optStyle, unixShortOption);
for (int i = 0; i < args.Length; i++)
{
m = re.Match(args[i]);
if (m.Success)
{
// see if there is a value
grp = m.Groups["shortname"];
if (grp != null && grp.Value != string.Empty)
{
isShort = true;
name = grp.Value;
value = m.Groups["shortvalue"].Value;
}
else
{
isShort = false;
name = m.Groups["longname"].Value;
value = m.Groups["longvalue"].Value;
// remove the '=' or ':' at the beginning of the value
if (value != null && value.Length > 0)
value = value.Substring(1);
}
if (optStyle == OptStyle.Unix)
{
if (isShort == false)
ParseLongOption(args, name, value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
// see if the value is just concatinated short options
else if (unixShortOption == UnixShortOption.CollapseShort)
{
// name is the first option
ParseShortOption(args, name[0], null, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
// parse the rest of the options that lie in the 'value' variable
if (value != null)
{
char[] unknownOptions;
ParseShortOptions(args, value.ToLower().ToCharArray(),
caseSesitive, ref i, dupOptHandleType, unknownOptHandleType,
foundDefinitions, out unknownOptions);
// don't do anything with unknown concatinated short options,
// they should not be considered options or arguments
}
}
else
// name is the first option
ParseShortOption(args, name[0], value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
else
{
if (name.Length == 1)
ParseShortOption(args, name[0], value, caseSesitive,
ref i, dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
else
ParseLongOption(args, name, value, caseSesitive, ref i,
dupOptHandleType, unknownOptHandleType, foundDefinitions,
out unknown);
}
// consider unknown options to be arguments
if (unknown)
arguments.Add(args[i]);
}
else
arguments.Add(args[i]);
}
// parse the environment
if (this.SearchEnvironment)
ParseEnvironment(foundDefinitions, caseSesitive);
results = new string[arguments.Count];
arguments.CopyTo(results, 0);
return results;
}
