+/*
+ * the variables optarg, optind, opterr and optopt are renamed with
+ * the custom_ prefix so that they don't interfere with getopt ones.
+ *
+ * Moreover they're static so they are visible only from within the
+ * file where this very file will be included.
+ */
+
+/*
+ * For communication from `custom_getopt' to the caller. When `custom_getopt' finds an
+ * option that takes an argument, the argument value is returned here.
+ */
+static char *custom_optarg;
+
+/*
+ * Index in ARGV of the next element to be scanned. This is used for
+ * communication to and from the caller and for communication between
+ * successive calls to `custom_getopt'.
+ *
+ * On entry to `custom_getopt', 1 means this is the first call; initialize.
+ *
+ * When `custom_getopt' returns -1, this is the index of the first of the non-option
+ * elements that the caller should itself scan.
+ *
+ * Otherwise, `custom_optind' communicates from one call to the next how much of ARGV
+ * has been scanned so far.
+ *
+ * 1003.2 says this must be 1 before any call.
+ */
+static int custom_optind = 1;
+
+/*
+ * Callers store zero here to inhibit the error message for unrecognized
+ * options.
+ */
+static int custom_opterr = 1;
+
+/*
+ * Set to an option character which was unrecognized. This must be initialized
+ * on some systems to avoid linking in the system's own getopt implementation.
+ */
+static int custom_optopt = '?';
+
+/*
+ * Exchange two adjacent subsequences of ARGV. One subsequence is elements
+ * [first_nonopt,last_nonopt) which contains all the non-options that have been
+ * skipped so far. The other is elements [last_nonopt,custom_optind), which contains
+ * all the options processed since those non-options were skipped.
+ * `first_nonopt' and `last_nonopt' are relocated so that they describe the new
+ * indices of the non-options in ARGV after they are moved.
+ */
+static void exchange(char **argv, struct custom_getopt_data *d)
+{
+ int bottom = d->first_nonopt;
+ int middle = d->last_nonopt;
+ int top = d->custom_optind;
+ char *tem;
+
+ /*
+ * Exchange the shorter segment with the far end of the longer segment.
+ * That puts the shorter segment into the right place. It leaves the
+ * longer segment in the right place overall, but it consists of two
+ * parts that need to be swapped next.
+ */
+ while (top > middle && middle > bottom) {
+ if (top - middle > middle - bottom) {
+ /* Bottom segment is the short one. */
+ int len = middle - bottom;
+ int i;
+
+ /* Swap it with the top part of the top segment. */
+ for (i = 0; i < len; i++) {
+ tem = argv[bottom + i];
+ argv[bottom + i] =
+ argv[top - (middle - bottom) + i];
+ argv[top - (middle - bottom) + i] = tem;
+ }
+ /* Exclude the moved bottom segment from further swapping. */
+ top -= len;
+ } else {
+ /* Top segment is the short one. */
+ int len = top - middle;
+ int i;
+
+ /* Swap it with the bottom part of the bottom segment. */
+ for (i = 0; i < len; i++) {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[middle + i];
+ argv[middle + i] = tem;
+ }
+ /* Exclude the moved top segment from further swapping. */
+ bottom += len;
+ }
+ }
+ /* Update records for the slots the non-options now occupy. */
+ d->first_nonopt += (d->custom_optind - d->last_nonopt);
+ d->last_nonopt = d->custom_optind;
+}
+
+/* Initialize the internal data when the first call is made. */
+static void custom_getopt_initialize(struct custom_getopt_data *d)
+{
+ /*
+ * Start processing options with ARGV-element 1 (since ARGV-element 0
+ * is the program name); the sequence of previously skipped non-option
+ * ARGV-elements is empty.
+ */
+ d->first_nonopt = d->last_nonopt = d->custom_optind;
+ d->nextchar = NULL;
+ d->initialized = 1;
+}
+
+#define NONOPTION_P (argv[d->custom_optind][0] != '-' || argv[d->custom_optind][1] == '\0')
+
+/* return: zero: continue, nonzero: return given value to user */
+static int shuffle_argv(int argc, char *const *argv,const struct option *longopts,
+ struct custom_getopt_data *d)
+{
+ /*
+ * Give FIRST_NONOPT & LAST_NONOPT rational values if CUSTOM_OPTIND has been
+ * moved back by the user (who may also have changed the arguments).
+ */
+ if (d->last_nonopt > d->custom_optind)
+ d->last_nonopt = d->custom_optind;
+ if (d->first_nonopt > d->custom_optind)
+ d->first_nonopt = d->custom_optind;
+ /*
+ * If we have just processed some options following some
+ * non-options, exchange them so that the options come first.
+ */
+ if (d->first_nonopt != d->last_nonopt &&
+ d->last_nonopt != d->custom_optind)
+ exchange((char **) argv, d);
+ else if (d->last_nonopt != d->custom_optind)
+ d->first_nonopt = d->custom_optind;
+ /*
+ * Skip any additional non-options and extend the range of
+ * non-options previously skipped.
+ */
+ while (d->custom_optind < argc && NONOPTION_P)
+ d->custom_optind++;
+ d->last_nonopt = d->custom_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 (d->custom_optind != argc && !strcmp(argv[d->custom_optind], "--")) {
+ d->custom_optind++;
+ if (d->first_nonopt != d->last_nonopt
+ && d->last_nonopt != d->custom_optind)
+ exchange((char **) argv, d);
+ else if (d->first_nonopt == d->last_nonopt)
+ d->first_nonopt = d->custom_optind;
+ d->last_nonopt = argc;
+ d->custom_optind = argc;
+ }
+ /*
+ * If we have done all the ARGV-elements, stop the scan and back over
+ * any non-options that we skipped and permuted.
+ */
+ if (d->custom_optind == argc) {
+ /*
+ * Set the next-arg-index to point at the non-options that we
+ * previously skipped, so the caller will digest them.
+ */
+ if (d->first_nonopt != d->last_nonopt)
+ d->custom_optind = d->first_nonopt;
+ 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 (NONOPTION_P) {
+ d->custom_optarg = argv[d->custom_optind++];
+ return 1;
+ }
+ /*
+ * We have found another option-ARGV-element. Skip the initial
+ * punctuation.
+ */
+ d->nextchar = (argv[d->custom_optind] + 1 + (longopts != NULL && argv[d->custom_optind][1] == '-'));
+ return 0;
+}
+
+/*
+ * Check whether the ARGV-element is a long option.
+ *
+ * If there's a long option "fubar" and the ARGV-element is "-fu", 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.
+ *
+ */
+static int check_long_opt(int argc, char *const *argv, const char *optstring,
+ const struct option *longopts, int *longind,
+ int print_errors, struct custom_getopt_data *d)
+{
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = -1;
+ int option_index;
+
+ for (nameend = d->nextchar; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */ ;
+
+ /* Test all long options for either exact match or abbreviated matches */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp(p->name, d->nextchar, nameend - d->nextchar)) {
+ if ((unsigned int) (nameend - d->nextchar)
+ == (unsigned int) strlen(p->name)) {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ } else if (pfound == NULL) {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ } else if (pfound->has_arg != p->has_arg
+ || pfound->flag != p->flag
+ || pfound->val != p->val)
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+ if (ambig && !exact) {
+ if (print_errors) {
+ fprintf(stderr,
+ "%s: option `%s' is ambiguous\n",
+ argv[0], argv[d->custom_optind]);
+ }
+ d->nextchar += strlen(d->nextchar);
+ d->custom_optind++;
+ d->custom_optopt = 0;
+ return '?';
+ }
+ if (pfound) {
+ option_index = indfound;
+ d->custom_optind++;
+ if (*nameend) {
+ if (pfound->has_arg != no_argument)
+ d->custom_optarg = nameend + 1;
+ else {
+ if (print_errors) {
+ if (argv[d->custom_optind - 1][1] == '-') {
+ /* --option */
+ fprintf(stderr, "%s: option `--%s' doesn't allow an argument\n",
+ argv[0], pfound->name);
+ } else {
+ /* +option or -option */
+ fprintf(stderr, "%s: option `%c%s' doesn't allow an argument\n",
+ argv[0], argv[d->custom_optind - 1][0], pfound->name);
+ }
+
+ }
+ d->nextchar += strlen(d->nextchar);
+ d->custom_optopt = pfound->val;
+ return '?';
+ }
+ } else if (pfound->has_arg == required_argument) {
+ if (d->custom_optind < argc)
+ d->custom_optarg = argv[d->custom_optind++];
+ else {
+ if (print_errors) {
+ fprintf(stderr,
+ "%s: option `%s' requires an argument\n",
+ argv[0],
+ argv[d->custom_optind - 1]);
+ }
+ d->nextchar += strlen(d->nextchar);
+ d->custom_optopt = pfound->val;
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ d->nextchar += strlen(d->nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag) {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+ /*
+ * 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 (print_errors) {
+ if (argv[d->custom_optind][1] == '-') {
+ /* --option */
+ fprintf(stderr,
+ "%s: unrecognized option `--%s'\n",
+ argv[0], d->nextchar);
+ } else {
+ /* +option or -option */
+ fprintf(stderr,
+ "%s: unrecognized option `%c%s'\n",
+ argv[0], argv[d->custom_optind][0],
+ d->nextchar);
+ }
+ }
+ d->nextchar = (char *) "";
+ d->custom_optind++;
+ d->custom_optopt = 0;
+ return '?';