public int getopt()
{
this.optarg = null;
if (this.endparse == true)
return -1;
if ((this.nextchar == null) || (this.nextchar.Length == 0))
{
// If we have just processed some options following some
// non-options, exchange them so that the options come first.
if (this.lastNonopt > this.optind)
this.lastNonopt = this.optind;
if (this.firstNonopt > this.optind)
this.firstNonopt = this.optind;
if (this.ordering == Order.Permute)
{
// If we have just processed some options following some
// non-options, exchange them so that the options come
// first.
if ((this.firstNonopt != this.lastNonopt) &&
(this.lastNonopt != this.optind))
this.exchange(this.argv);
else if (this.lastNonopt != this.optind)
this.firstNonopt = this.optind;
// Skip any additional non-options
// and extend the range of non-options previously skipped.
while ((this.optind < this.argv.Length) &&
((this.argv[optind].Length == 0) ||
(this.argv[this.optind][0] != '-') ||
this.argv[optind].Equals("-")))
this.optind++;
this.lastNonopt = this.optind;
}
// The special ARGV-element "--" means premature end of
// options. Skip it like a null option, then exchange with
// previous non-options as if it were an option, then skip
// everything else like a non-option.
if ((this.optind != this.argv.Length) &&
this.argv[this.optind].Equals("--"))
{
this.optind++;
if ((this.firstNonopt != this.lastNonopt) &&
(this.lastNonopt != this.optind))
this.exchange(this.argv);
else if (this.firstNonopt == this.lastNonopt)
this.firstNonopt = this.optind;
this.lastNonopt = this.argv.Length;
this.optind = this.argv.Length;
}
// If we have done all the ARGV-elements, stop the scan
// and back over any non-options that we skipped and permuted.
if (this.optind == this.argv.Length)
{
// Set the next-arg-index to point at the non-options that
// we previously skipped, so the caller will digest them.
if (this.firstNonopt != this.lastNonopt)
this.optind = this.firstNonopt;
return -1;
}
// If we have come to a non-option and did not permute it,
// either stop the scan or describe it to the caller and pass
// it by.
if ((this.argv[this.optind].Length == 0) ||
(this.argv[this.optind][0] != '-') ||
this.argv[this.optind].Equals("-"))
{
if (this.ordering == Order.RequireOrder)
return -1;
this.optarg = this.argv[optind++];
return 1;
}
// We have found another option-ARGV-element.
// Skip the initial punctuation.
if (this.argv[optind].StartsWith("--"))
this.nextchar = this.argv[this.optind].Substring(2);
else
this.nextchar = this.argv[this.optind].Substring(1);
}
// Decode the current option-ARGV-element.
/* Check whether the ARGV-element is a long option.
If longOnly and the ARGV-element has the form "-f", where f is
a valid short option, don't consider it an abbreviated form of
a long option that starts with f. Otherwise there would be no
way to give the -f short option.
On the other hand, if there's a long option "fubar" and the
ARGV-element is "-fu", do consider that an abbreviation of the
long option, just like "--fu", and not "-f" with arg "u".
This distinction seems to be the most useful approach.
*/
if ((this.longOptions != null) &&
(this.argv[this.optind].StartsWith("--") || (this.longOnly &&
((this.argv[this.optind].Length > 2) ||
(this.optstring.IndexOf(this.argv[this.optind][1]) == -1)))))
{
int c = this.checkLongOption();
if (this.longoptHandled)
return c;
// Can't find it as a long option. If this is not
// getopt_long_only, or the option starts with "--" or is not a
// valid short option, then it's an error. Otherwise interpret
// it as a short option.
if (!this.longOnly || this.argv[this.optind].StartsWith("--")
|| (this.optstring.IndexOf(this.nextchar[0]) == - 1))
{
if (this.opterr)
{
if (this.argv[this.optind].StartsWith("--"))
{
object[] msgArgs = new object[]{
this.progname, this.nextchar };
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.unrecognized",
this.cultureInfo), msgArgs);
}
else
{
object[] msgArgs = new object[]{ this.progname,
this.argv[optind][0], this.nextchar};
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.unrecognized2",
this.cultureInfo), msgArgs);
}
}
this.nextchar = "";
++this.optind;
this.optopt = 0;
return '?';
}
} // if (longopts)
// Look at and handle the next short option-character */
int c2 = this.nextchar[0]; //**** Do we need to check for empty str?
if (this.nextchar.Length > 1)
this.nextchar = this.nextchar.Substring(1);
else
this.nextchar = "";
string temp = null;
if (this.optstring.IndexOf((char) c2) != - 1)
temp = this.optstring.Substring(
this.optstring.IndexOf((char) c2));
if (this.nextchar.Length == 0)
++this.optind;
if ((temp == null) || (c2 == ':'))
{
if (this.opterr)
{
if (this.posixlyCorrect)
{
// 1003.2 specifies the format of this message
object[] msgArgs = new object[]{
this.progname, (char) c2 };
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.illegal",
this.cultureInfo), msgArgs);
}
else
{
object[] msgArgs = new object[]{
this.progname, (char) c2 };
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.invalid",
this.cultureInfo), msgArgs);
}
}
this.optopt = c2;
return '?';
}
// Convenience. Treat POSIX -W foo same as long option --foo
if ((temp[0] == 'W') && (temp.Length > 1) && (temp[1] == ';'))
{
if (this.nextchar.Length != 0)
{
this.optarg = this.nextchar;
}
// No further cars in this argv element and no more argv
// elements
else if (this.optind == this.argv.Length)
{
if (this.opterr)
{
// 1003.2 specifies the format of this message.
object[] msgArgs = new object[]{
this.progname, (char) c2 };
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.requires2",
this.cultureInfo), msgArgs);
}
this.optopt = c2;
if (this.optstring[0] == ':')
return ':';
else
return '?';
}
else
{
// We already incremented `optind' once; increment it again
// when taking next ARGV-elt as argument.
this.nextchar = this.argv[this.optind];
this.optarg = this.argv[this.optind];
}
c2 = this.checkLongOption();
if (this.longoptHandled)
return c2;
// Let the application handle it
else
{
this.nextchar = null;
++this.optind;
return 'W';
}
}
if ((temp.Length > 1) && (temp[1] == ':'))
{
if ((temp.Length > 2) && (temp[2] == ':'))
// This is an option that accepts and argument optionally
{
if (this.nextchar.Length != 0)
{
this.optarg = this.nextchar;
++this.optind;
}
else
{
this.optarg = null;
}
this.nextchar = null;
}
else
{
if (this.nextchar.Length != 0)
{
this.optarg = this.nextchar;
++this.optind;
}
else if (this.optind == this.argv.Length)
{
if (this.opterr)
{
// 1003.2 specifies the format of this message
object[] msgArgs = new object[]{
this.progname, (char) c2};
System.Console.Error.WriteLine(
this.resManager.GetString("getopt.requires2",
this.cultureInfo), msgArgs);
}
this.optopt = c2;
if (this.optstring[0] == ':')
return ':';
else
return '?';
}
else
{
this.optarg = this.argv[this.optind];
++this.optind;
// Ok, here's an obscure Posix case. If we have o:,
// and we get -o -- foo, then we're supposed to skip
// the --, end parsing of options, and make foo an
// operand to -o. Only do this in Posix mode.
if (this.posixlyCorrect && this.optarg.Equals("--"))
{
// If end of argv, error out
if (this.optind == this.argv.Length)
{
if (this.opterr)
{
// 1003.2 specifies the format of this
// message
object[] msgArgs = new object[]{
this.progname, (char) c2};
System.Console.Error.WriteLine(
this.resManager.GetString(
"getopt.requires2", this.cultureInfo),
msgArgs);
}
this.optopt = c2;
if (this.optstring[0] == ':')
return ':';
else
return '?';
}
// Set new optarg and set to end. Don't permute as
// we do on -- up above since we know we aren't in
// permute mode because of Posix.
this.optarg = this.argv[this.optind];
++this.optind;
this.firstNonopt = this.optind;
this.lastNonopt = this.argv.Length;
this.endparse = true;
}
}
this.nextchar = null;
}
}
return c2;
}