getopt.c

Axis 221 camera embedded programing interface

	}

	/* We have found another option-ARGV-element.
	   Skip the initial punctuation.  */

	nextchar = (argv[optind] + 1
		+ (longopts != NULL && argv[optind][1] == '-'));
    }

    /* Decode the current option-ARGV-element.  */

    /* Check whether the ARGV-element is a long option.

       If long_only 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 (longopts != NULL
	    && (argv[optind][1] == '-'
		|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
    {
	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 = 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, nextchar, nameend - nextchar))
	    {
		if ((unsigned int) (nameend - 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 (long_only
			|| 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[optind]);
	    }
	    nextchar += strlen (nextchar);
	    optind++;
	    optopt = 0;
	    return '?';
	}

	if (pfound != NULL)
	{
	    option_index = indfound;
	    optind++;
	    if (*nameend)
	    {
		/* Don't test has_arg with >, because some C compilers don't
		   allow it to be used on enums.  */
		if (pfound->has_arg)
		    optarg = nameend + 1;
		else
		{
		    if (print_errors)
		    {

			if (argv[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[optind - 1][0], pfound->name);
			}

		    }

		    nextchar += strlen (nextchar);

		    optopt = pfound->val;
		    return '?';
		}
	    }
	    else if (pfound->has_arg == 1)
	    {
		if (optind < argc)
		    optarg = argv[optind++];
		else
		{
		    if (print_errors)
		    {
			fprintf (stderr,
				_("%s: option `%s' requires an argument\n"),
				argv[0], argv[optind - 1]);
		    }
		    nextchar += strlen (nextchar);
		    optopt = pfound->val;
		    return optstring[0] == ':' ? ':' : '?';
		}
	    }
	    nextchar += strlen (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 (!long_only || argv[optind][1] == '-'
		|| my_index (optstring, *nextchar) == NULL)
	{
	    if (print_errors)
	    {

		if (argv[optind][1] == '-')
		{
		    /* --option */
		    fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
			    argv[0], nextchar);
		}
		else
		{
		    /* +option or -option */
		    fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
			    argv[0], argv[optind][0], nextchar);
		}

	    }
	    nextchar = (char *) "";
	    optind++;
	    optopt = 0;
	    return '?';
	}
    }

    /* Look at and handle the next short option-character.  */

    {
	char c = *nextchar++;
	char *temp = my_index (optstring, c);

	/* Increment `optind' when we start to process its last character.  */
	if (*nextchar == '\0')
	    ++optind;

	if (temp == NULL || c == ':')
	{
	    if (print_errors)
	    {
		    /* 1003.2 specifies the format of this message.  */
		    fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
	    }
	    optopt = c;
	    return '?';
	}
#ifdef SPECIAL_TREATMENT_FOR_W
	/* Convenience. Treat POSIX -W foo same as long option --foo */
	if (temp[0] == 'W' && temp[1] == ';')
	{
	    char *nameend;
	    const struct option *p;
	    const struct option *pfound = NULL;
	    int exact = 0;
	    int ambig = 0;
	    int indfound = 0;
	    int option_index;

	    /* This is an option that requires an argument.  */
	    if (*nextchar != '\0')
	    {
		optarg = nextchar;
		/* If we end this ARGV-element by taking the rest as an arg,
		   we must advance to the next element now.  */
		optind++;
	    }
	    else if (optind == argc)
	    {
		if (print_errors)
		{
		    /* 1003.2 specifies the format of this message.  */
		    fprintf (stderr, _("%s: option requires an argument -- %c\n"),
			    argv[0], c);
		}
		optopt = c;
		if (optstring[0] == ':')
		    c = ':';
		else
		    c = '?';
		return c;
	    }
	    else
		/* We already incremented `optind' once;
		   increment it again when taking next ARGV-elt as argument.  */
		optarg = argv[optind++];

	    /* optarg is now the argument, see if it's in the
	       table of longopts.  */

	    for (nextchar = nameend = optarg; *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, nextchar, nameend - nextchar))
		{
		    if ((unsigned int) (nameend - nextchar) == 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
			/* Second or later nonexact match found.  */
			ambig = 1;
		}
	    if (ambig && !exact)
	    {
		if (print_errors)
		{
		    fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
			    argv[0], argv[optind]);
		}
		nextchar += strlen (nextchar);
		optind++;
		return '?';
	    }
	    if (pfound != NULL)
	    {
		option_index = indfound;
		if (*nameend)
		{
		    /* Don't test has_arg with >, because some C compilers don't
		       allow it to be used on enums.  */
		    if (pfound->has_arg)
			optarg = nameend + 1;
		    else
		    {
			if (print_errors)
			{
			    fprintf (stderr, _("\
					%s: option `-W %s' doesn't allow an argument\n"),
				    argv[0], pfound->name);
			}

			nextchar += strlen (nextchar);
			return '?';
		    }
		}
		else if (pfound->has_arg == 1)
		{
		    if (optind < argc)
			optarg = argv[optind++];
		    else
		    {
			if (print_errors)
			{
			    fprintf (stderr,
				    _("%s: option `%s' requires an argument\n"),
				    argv[0], argv[optind - 1]);
			}
			nextchar += strlen (nextchar);
			return optstring[0] == ':' ? ':' : '?';
		    }
		}
		nextchar += strlen (nextchar);
		if (longind != NULL)
		    *longind = option_index;
		if (pfound->flag)
		{
		    *(pfound->flag) = pfound->val;
		    return 0;
		}
		return pfound->val;
	    }
	    nextchar = NULL;
	    return 'W';	/* Let the application handle it.   */
	}
#endif
	if (temp[1] == ':')
	{
	    if (temp[2] == ':')
	    {
		/* This is an option that accepts an argument optionally.  */
		if (*nextchar != '\0')
		{
		    optarg = nextchar;
		    optind++;
		}
		else
		    optarg = NULL;
		nextchar = NULL;
	    }
	    else
	    {
		/* This is an option that requires an argument.  */
		if (*nextchar != '\0')
		{
		    optarg = nextchar;
		    /* If we end this ARGV-element by taking the rest as an arg,
		       we must advance to the next element now.  */
		    optind++;
		}
		else if (optind == argc)
		{
		    if (print_errors)
		    {
			/* 1003.2 specifies the format of this message.  */
			fprintf (stderr,
				_("%s: option requires an argument -- %c\n"),
				argv[0], c);
		    }
		    optopt = c;
		    if (optstring[0] == ':')
			c = ':';
		    else
			c = '?';
		}
		else
		    /* We already incremented `optind' once;
		       increment it again when taking next ARGV-elt as argument.  */
		    optarg = argv[optind++];
		nextchar = NULL;
	    }
	}
	return c;
    }
}

int getopt (int argc, char *const *argv, const char *optstring)
{
    return _getopt_internal (argc, argv, optstring, 
	    (const struct option *) 0, (int *) 0, 0);
}

int getopt_long (int argc, char *const *argv, const char *options, 
	const struct option *long_options, int *opt_index)
{
    return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.
   If an option that starts with '-' (not '--') doesn't match a long option,
   but does match a short option, it is parsed as a short option
   instead.  */

int getopt_long_only (int argc, char *const *argv, const char *options, 
	const struct option *long_options, int *opt_index)
{
    return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}