* cygwin.din (__argv): Export.

(__argc): Ditto.
(__progname): Ditto.
* include/getopt.h (getopt_long): constify arguments.
* lib/getopt.c: Import new file from NetBSD.

1 files changed, 399 insertions, 297 deletions

diff --git a/winsup/cygwin/lib/getopt.c b/winsup/cygwin/lib/getopt.c
index da7ecfc..7049f80 100644
--- a/winsup/cygwin/lib/getopt.c
+++ b/winsup/cygwin/lib/getopt.c
@@ -1,6 +1,11 @@
-/*
- * Copyright (c) 1987, 1993, 1994, 1996
- *	The Regents of the University of California.  All rights reserved.
+/*	$NetBSD: getopt_long.c,v 1.12 2001/04/24 09:07:43 joda Exp $	*/
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -12,380 +17,477 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *        This product includes software developed by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <stdio.h>
+#include <sys/cdefs.h>
+
+/*#include "namespace.h"*/
+
+#include <assert.h>
+#include <errno.h>
+/*#include <err.h>*/
 #include <stdlib.h>
 #include <string.h>
-#include "getopt.h"
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdio.h>
 
-int	  opterr = 1;	/* if error message should be printed */
-int	  optind = 1;	/* index into parent argv vector */
-int	  optopt;	/* character checked for validity */
-int	  optreset;	/* reset getopt */
-char	  *optarg;	/* argument associated with option */
+#define REPLACE_GETOPT
 
-static char * __progname (char *);
-int getopt_internal (int, char * const *, const char *);
+#define _DIAGASSERT(x) do {} while (0)
 
-static char * __progname(nargv0)
-    char * nargv0;
-{
-    char * tmp = strrchr(nargv0, '/');
-    if (tmp) tmp++; else tmp = nargv0;
-    return(tmp);
-}
+#ifdef REPLACE_GETOPT
+#ifdef __weak_alias
+__weak_alias(getopt,_getopt)
+#endif
+int	opterr = 1;		/* if error message should be printed */
+int	optind = 1;		/* index into parent argv vector */
+int	optopt = '?';		/* character checked for validity */
+int	optreset;		/* reset getopt */
+char    *optarg;		/* argument associated with option */
+#endif
+
+#ifdef __weak_alias
+__weak_alias(getopt_long,_getopt_long)
+#endif
+
+
+#define IGNORE_FIRST	(*options == '-' || *options == '+')
+#define PRINT_ERROR	((opterr) && ((*options != ':') \
+				      || (IGNORE_FIRST && options[1] != ':')))
+#define IS_POSIXLY_CORRECT (getenv("POSIXLY_CORRECT") != NULL)
+#define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
+/* XXX: GNU ignores PC if *options == '-' */
+#define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
 
+/* return values */
 #define	BADCH	(int)'?'
-#define	BADARG	(int)':'
+#define	BADARG		((IGNORE_FIRST && options[1] == ':') \
+			 || (*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+
 #define	EMSG	""
 
+static int getopt_internal __P((int, char * const *, const char *));
+static int gcd __P((int, int));
+static void permute_args __P((int, int, int, char * const *));
+
+static const char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+extern char __declspec(dllimport) *__progname;
+
+static void
+_vwarnx(const char *fmt, va_list ap)
+{
+  (void)fprintf(stderr, "%s: ", __progname);
+  if (fmt != NULL)
+    (void)vfprintf(stderr, fmt, ap);
+  (void)fprintf(stderr, "\n");
+}
+
+static void
+warnx(const char *fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+  _vwarnx(fmt, ap);
+  va_end(ap);
+}
+
 /*
- * getopt --
- *	Parse argc/argv argument vector.
+ * Compute the greatest common divisor of a and b.
  */
-int
-getopt_internal(nargc, nargv, ostr)
-	int nargc;
+static int
+gcd(a, b)
+	int a;
+	int b;
+{
+	int c;
+
+	c = a % b;
+	while (c != 0) {
+		a = b;
+		b = c;
+		c = a % b;
+	}
+	   
+	return b;
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(nonopt_start, nonopt_end, opt_end, nargv)
+	int nonopt_start;
+	int nonopt_end;
+	int opt_end;
 	char * const *nargv;
-	const char *ostr;
 {
-	static const char *place = EMSG;	/* option letter processing */
+	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+	char *swap;
+
+	_DIAGASSERT(nargv != NULL);
+
+	/*
+	 * compute lengths of blocks and number and size of cycles
+	 */
+	nnonopts = nonopt_end - nonopt_start;
+	nopts = opt_end - nonopt_end;
+	ncycle = gcd(nnonopts, nopts);
+	cyclelen = (opt_end - nonopt_start) / ncycle;
+
+	for (i = 0; i < ncycle; i++) {
+		cstart = nonopt_end+i;
+		pos = cstart;
+		for (j = 0; j < cyclelen; j++) {
+			if (pos >= nonopt_end)
+				pos -= nnonopts;
+			else
+				pos += nopts;
+			swap = nargv[pos];
+			/* LINTED const cast */
+			((char **) nargv)[pos] = nargv[cstart];
+			/* LINTED const cast */
+			((char **)nargv)[cstart] = swap;
+		}
+	}
+}
+
+/*
+ * getopt_internal --
+ *	Parse argc/argv argument vector.  Called by user level routines.
+ *  Returns -2 if -- is found (can be long option or end of options marker).
+ */
+static int
+getopt_internal(int nargc, char *const * nargv, const char *options)
+{
 	char *oli;				/* option letter list index */
+	int optchar;
+
+	_DIAGASSERT(nargv != NULL);
+	_DIAGASSERT(options != NULL);
+
+	optarg = NULL;
 
+	/*
+	 * XXX Some programs (like rsyncd) expect to be able to
+	 * XXX re-initialize optind to 0 and have getopt_long(3)
+	 * XXX properly function again.  Work around this braindamage.
+	 */
+	if (optind == 0)
+		optind = 1;
+
+	if (optreset)
+		nonopt_start = nonopt_end = -1;
+start:
 	if (optreset || !*place) {		/* update scanning pointer */
 		optreset = 0;
-		if (optind >= nargc || *(place = nargv[optind]) != '-') {
+		if (optind >= nargc) {          /* end of argument vector */
 			place = EMSG;
-			return (-1);
+			if (nonopt_end != -1) {
+				/* do permutation, if we have to */
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			else if (nonopt_start != -1) {
+				/*
+				 * If we skipped non-options, set optind
+				 * to the first of them.
+				 */
+				optind = nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return -1;
 		}
-		if (place[1] && *++place == '-') {	/* found "--" */
-			/* ++optind; */
+		if ((*(place = nargv[optind]) != '-')
+		    || (place[1] == '\0')) {    /* found non-option */
 			place = EMSG;
-			return (-2);
+			if (IN_ORDER) {
+				/*
+				 * GNU extension: 
+				 * return non-option as argument to option 1
+				 */
+				optarg = nargv[optind++];
+				return INORDER;
+			}
+			if (!PERMUTE) {
+				/*
+				 * if no permutation wanted, stop parsing
+				 * at first non-option
+				 */
+				return -1;
+			}
+			/* do permutation */
+			if (nonopt_start == -1)
+				nonopt_start = optind;
+			else if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				nonopt_start = optind -
+				    (nonopt_end - nonopt_start);
+				nonopt_end = -1;
+			}
+			optind++;
+			/* process next argument */
+			goto start;
 		}
-	}					/* option letter okay? */
-	if ((optopt = (int)*place++) == (int)':' ||
-	    !(oli = strchr(ostr, optopt))) {
-		/*
-		 * if the user didn't specify '-' as an option,
-		 * assume it means -1.
-		 */
-		if (optopt == (int)'-')
-			return (-1);
+		if (nonopt_start != -1 && nonopt_end == -1)
+			nonopt_end = optind;
+		if (place[1] && *++place == '-') {	/* found "--" */
+			place++;
+			return -2;
+		}
+	}
+	if ((optchar = (int)*place++) == (int)':' ||
+	    (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
+		/* option letter unknown or ':' */
 		if (!*place)
 			++optind;
-		if (opterr && *ostr != ':')
-			(void)fprintf(stderr,
-			    "%s: illegal option -- %c\n", __progname(nargv[0]), optopt);
-		return (BADCH);
+		if (PRINT_ERROR)
+			warnx(illoptchar, optchar);
+		optopt = optchar;
+		return BADCH;
 	}
-	if (*++oli != ':') {			/* don't need argument */
-		optarg = NULL;
+	if (optchar == 'W' && oli[1] == ';') {		/* -W long-option */
+		/* XXX: what if no long options provided (called by getopt)? */
+		if (*place) 
+			return -2;
+
+		if (++optind >= nargc) {	/* no arg */
+			place = EMSG;
+			if (PRINT_ERROR)
+				warnx(recargchar, optchar);
+			optopt = optchar;
+			return BADARG;
+		} else				/* white space */
+			place = nargv[optind];
+		/*
+		 * Handle -W arg the same as --arg (which causes getopt to
+		 * stop parsing).
+		 */
+		return -2;
+	}
+	if (*++oli != ':') {			/* doesn't take argument */
 		if (!*place)
 			++optind;
-	} else {				/* need an argument */
+	} else {				/* takes (optional) argument */
+		optarg = NULL;
 		if (*place)			/* no white space */
-			optarg = (char *)place;
-		else if (nargc <= ++optind) {	/* no arg */
-			place = EMSG;
-			if ((opterr) && (*ostr != ':'))
-				(void)fprintf(stderr,
-				    "%s: option requires an argument -- %c\n",
-				    __progname(nargv[0]), optopt);
-			return (BADARG);
-		} else				/* white space */
-			optarg = nargv[optind];
+			optarg = (char *) place;
+		/* XXX: disable test for :: if PC? (GNU doesn't) */
+		else if (oli[1] != ':') {	/* arg not optional */
+			if (++optind >= nargc) {	/* no arg */
+				place = EMSG;
+				if (PRINT_ERROR)
+					warnx(recargchar, optchar);
+				optopt = optchar;
+				return BADARG;
+			} else
+				optarg = nargv[optind];
+		}
 		place = EMSG;
 		++optind;
 	}
-	return (optopt);			/* dump back option letter */
+	/* dump back option letter */
+	return optchar;
 }
 
+#ifdef REPLACE_GETOPT
 /*
  * getopt --
  *	Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the real getopt]
  */
 int
-getopt(nargc, nargv, ostr)
-	int nargc;
-	char * const *nargv;
-	const char *ostr;
+getopt(int nargc, char * const *nargv, const char *options)
 {
 	int retval;
 
-	if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {
-		retval = -1;
+	_DIAGASSERT(nargv != NULL);
+	_DIAGASSERT(options != NULL);
+
+	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
 		++optind;
+		/*
+		 * We found an option (--), so if we skipped non-options,
+		 * we have to permute.
+		 */
+		if (nonopt_end != -1) {
+			permute_args(nonopt_start, nonopt_end, optind,
+				       nargv);
+			optind -= nonopt_end - nonopt_start;
+		}
+		nonopt_start = nonopt_end = -1;
+		retval = -1;
 	}
-	return(retval);
+	return retval;
 }
+#endif
 
 /*
  * getopt_long --
  *	Parse argc/argv argument vector.
  */
 int
-getopt_long(nargc, nargv, options, long_options, index)
-     int nargc;
-     char ** nargv;
-     char * options;
-     struct option * long_options;
-     int * index;
+getopt_long(int nargc, char * const *nargv, const char *options,
+	    const struct option *long_options, int *idx)
 {
 	int retval;
 
+	_DIAGASSERT(nargv != NULL);
+	_DIAGASSERT(options != NULL);
+	_DIAGASSERT(long_options != NULL);
+	/* idx may be NULL */
+
 	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
-		char *current_argv = nargv[optind++] + 2, *has_equal;
-		int i, match = -1;
+		char *current_argv, *has_equal;
 		size_t current_argv_len;
+		int i, match;
+
+		current_argv = place;
+		match = -1;
+
+		optind++;
+		place = EMSG;
 
-		if (*current_argv == '\0') {
-			return(-1);
+		if (*current_argv == '\0') {		/* found "--" */
+			/*
+			 * We found an option (--), so if we skipped
+			 * non-options, we have to permute.
+			 */
+			if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return -1;
 		}
-		if ((has_equal = strchr(current_argv, '='))) {
+		if ((has_equal = strchr(current_argv, '=')) != NULL) {
+			/* argument found (--option=arg) */
 			current_argv_len = has_equal - current_argv;
 			has_equal++;
 		} else
 			current_argv_len = strlen(current_argv);
-
+	    
 		for (i = 0; long_options[i].name; i++) {
-			if (strncmp(current_argv, long_options[i].name, current_argv_len))
+			/* find matching long option */
+			if (strncmp(current_argv, long_options[i].name,
+			    current_argv_len))
 				continue;
 
-			if (strlen(long_options[i].name) == current_argv_len) {
+			if (strlen(long_options[i].name) ==
+			    (unsigned)current_argv_len) {
+				/* exact match */
 				match = i;
 				break;
 			}
-			if (match == -1)
+			if (match == -1)		/* partial match */
 				match = i;
+			else {
+				/* ambiguous abbreviation */
+				if (PRINT_ERROR)
+					warnx(ambig, (int)current_argv_len,
+					     current_argv);
+				optopt = 0;
+				return BADCH;
+			}
 		}
-		if (match != -1) {
-			if (long_options[match].has_arg) {
+		if (match != -1) {			/* option found */
+		        if (long_options[match].has_arg == no_argument
+			    && has_equal) {
+				if (PRINT_ERROR)
+					warnx(noarg, (int)current_argv_len,
+					     current_argv);
+				/*
+				 * XXX: GNU sets optopt to val regardless of
+				 * flag
+				 */
+				if (long_options[match].flag == NULL)
+					optopt = long_options[match].val;
+				else
+					optopt = 0;
+				return BADARG;
+			}
+			if (long_options[match].has_arg == required_argument ||
+			    long_options[match].has_arg == optional_argument) {
 				if (has_equal)
 					optarg = has_equal;
-				else
+				else if (long_options[match].has_arg ==
+				    required_argument) {
+					/*
+					 * optional argument doesn't use
+					 * next nargv
+					 */
 					optarg = nargv[optind++];
+				}
 			}
-			if ((long_options[match].has_arg == 1) && (optarg == NULL)) {
-				/* Missing option, leading : indecates no error */
-				if ((opterr) && (*options != ':'))
-					(void)fprintf(stderr,
-				      "%s: option requires an argument -- %s\n",
-				      __progname(nargv[0]), current_argv);
-				return (BADARG);
+			if ((long_options[match].has_arg == required_argument)
+			    && (optarg == NULL)) {
+				/*
+				 * Missing argument; leading ':'
+				 * indicates no error should be generated
+				 */
+				if (PRINT_ERROR)
+					warnx(recargstring, current_argv);
+				/*
+				 * XXX: GNU sets optopt to val regardless
+				 * of flag
+				 */
+				if (long_options[match].flag == NULL)
+					optopt = long_options[match].val;
+				else
+					optopt = 0;
+				--optind;
+				return BADARG;
 			}
-		} else { /* No matching argument */
-			if ((opterr) && (*options != ':'))
-				(void)fprintf(stderr,
-				    "%s: illegal option -- %s\n", __progname(nargv[0]), current_argv);
-			return (BADCH);
+		} else {			/* unknown option */
+			if (PRINT_ERROR)
+				warnx(illoptstring, current_argv);
+			optopt = 0;
+			return BADCH;
 		}
 		if (long_options[match].flag) {
 			*long_options[match].flag = long_options[match].val;
 			retval = 0;
-		} else
+		} else 
 			retval = long_options[match].val;
-		if (index)
-			*index = match;
-	}
-	return(retval);
-}
-/*****************************************************************/
-
-
-
-
-
-
-#include <stdio.h>
-#include "getopt.h"
-
-/* Stuff for getopt */
-static struct option long_options[] = {
-	{ (char *)"simple", 0, NULL, 's' },
-	{ (char *)"t", 0, NULL, 't' },
-	{ (char *)"u", 1, NULL, 'u' },
-	{ (char *)"v", 0, NULL, 'v' },
-	/* Do not reorder the following */
-	{ (char *)"yy", 0, NULL, 'Y' },
-	{  (char *)"y", 0, NULL, 'y' },
-	{ (char *)"zz", 0, NULL, 'z' },
-	{ (char *)"zzz", 0, NULL, 'Z' },
-	{ NULL, 0, NULL, 0 }
-};
-extern char * optarg;
-extern int optreset;
-extern int optind;
-
-int test_getopt_long(args, expected_result)
-    char ** args, * expected_result;
-{
-	char actual_result[256];
-	int count, pass, i;
-
-	pass = 0;
-	optind = 1;
-	optreset = 1;
-	for (count = 0; args[count]; count++);
-	while ((i = getopt_long(count, args, (char *)"ab:", long_options, NULL)) != EOF) {
-		switch(i) {
-		case 'u':
-			if (strcmp(optarg, "bogus")) {
-				printf("--u option does not have bogus optarg.\n");
-				return(1);
-			}
-		case 'Y':
-		case 's':
-		case 't':
-		case 'v':
-		case 'y':
-		case 'z':
-			actual_result[pass++] = i;
-			break;
-		default:
-			actual_result[pass++] = '?';
-			break;
-		}
-	}
-
-	actual_result[pass] = '\0';
-	return(strcmp(actual_result, expected_result));
-
-}
-
-#if 0
-int usage(value)
-	int value;
-{
-	printf("test_getopt [-d]\n");
-	exit(value);
-}
-#endif
-
-#if 0
-
-/*
- * Static arglists for individual tests
- * This is ugly and maybe I should just use a variable arglist
- */
-const char *argv1[] = { "Test simple", "--s", NULL };
-const char *argv2[] = { "Test multiple", "--s", "--t", NULL };
-const char *argv3[] = { "Test optarg with space", "--u", "bogus", NULL };
-const char *argv4[] = { "Test optarg with equal", "--u=bogus", NULL };
-const char *argv5[] = { "Test complex", "--s", "--t", "--u", "bogus", "--v", NULL };
-const char *argv6[] = { "Test exact", "--y", NULL };
-const char *argv7[] = { "Test abbr", "--z", NULL };
-const char *argv8[] = { "Test simple termination", "--z", "foo", "--z", NULL };
-const char *argv9[] = { "Test -- termination", "--z", "--", "--z", NULL };
-
-int debug = 0;
-int main(argc, argv)
-    int argc;
-    char ** argv;
-{
-	int i;
-
-	/* Of course if getopt() has a bug this won't work */
-	while ((i = getopt(argc, argv, "d")) != EOF) {
-		switch(i) {
-		case 'd':
-			debug++;
-			break;
-		default:
-			usage(1);
-			break;
-		}
-	}
-
-	/* Test getopt_long() */
-	{
-		if (test_getopt_long(argv1, "s")) {
-			printf("Test simple failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test multiple arguments */
-	{
-		if (test_getopt_long(argv2, "st")) {
-			printf("Test multiple failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test optarg with space */
-	{
-		if (test_getopt_long(argv3, "u")) {
-			printf("Test optarg with space failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test optarg with equal */
-	{
-		if (test_getopt_long(argv4, "u")) {
-			printf("Test optarg with equal failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test complex */
-	{
-		if (test_getopt_long(argv5, "stuv")) {
-			printf("Test complex failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test that exact matches override abbr matches */
-	{
-		if (test_getopt_long(argv6, "y")) {
-			printf("Test exact failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test that abbr matches are first match. */
-	{
-		if (test_getopt_long(argv7, "z")) {
-			printf("Test abbr failed.\n");
-			exit(1);
-		}
-	}
-
-	/* Test that option termination succeeds */
-	{
-		if (test_getopt_long(argv8, "z")) {
-			printf("Test simple termination failed.\n");
-			exit(1);
-		}
+		if (idx)
+			*idx = match;
 	}
-
-	/* Test that "--" termination succeeds */
-	{
-		if (test_getopt_long(argv9, "z")) {
-			printf("Test -- termination failed.\n");
-			exit(1);
-		}
-	}
-	exit(0);
+	return retval;
 }
-#endif