d->__first_nonopt = d->optind;      if (d->__ordering == PERMUTE)	{	  /* 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->optind)	    exchange ((char **) argv, d);	  else if (d->__last_nonopt != d->optind)	    d->__first_nonopt = d->optind;	  /* Skip any additional non-options	     and extend the range of non-options previously skipped.  */	  while (d->optind < argc && NONOPTION_P)	    d->optind++;	  d->__last_nonopt = d->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->optind != argc && !strcmp (argv[d->optind], "--"))	{	  d->optind++;	  if (d->__first_nonopt != d->__last_nonopt	      && d->__last_nonopt != d->optind)	    exchange ((char **) argv, d);	  else if (d->__first_nonopt == d->__last_nonopt)	    d->__first_nonopt = d->optind;	  d->__last_nonopt = argc;	  d->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->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->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)	{	  if (d->__ordering == REQUIRE_ORDER)	    return -1;	  d->optarg = argv[d->optind++];	  return 1;	}      /* We have found another option-ARGV-element.	 Skip the initial punctuation.  */      d->__nextchar = (argv[d->optind] + 1		  + (longopts != NULL && argv[d->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[d->optind][1] == '-'	  || (long_only && (argv[d->optind][2]			    || !strchr (optstring, argv[d->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 = 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 (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)	    {#if defined _LIBC && defined USE_IN_LIBIO	      char *buf;	      if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"),			      argv[0], argv[d->optind]) >= 0)		{		  _IO_flockfile (stderr);		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;		  if (_IO_fwide (stderr, 0) > 0)		    __fwprintf (stderr, L"%s", buf);		  else		    fputs (buf, stderr);		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;		  _IO_funlockfile (stderr);		  free (buf);		}#else	      fprintf (stderr, _("%s: option `%s' is ambiguous\n"),		       argv[0], argv[d->optind]);#endif	    }	  d->__nextchar += strlen (d->__nextchar);	  d->optind++;	  d->optopt = 0;	  return '?';	}      if (pfound != NULL)	{	  option_index = indfound;	  d->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)		d->optarg = nameend + 1;	      else		{		  if (print_errors)		    {#if defined _LIBC && defined USE_IN_LIBIO		      char *buf;		      int n;#endif		      if (argv[d->optind - 1][1] == '-')			{			  /* --option */#if defined _LIBC && defined USE_IN_LIBIO			  n = __asprintf (&buf, _("\%s: option `--%s' doesn't allow an argument\n"),					  argv[0], pfound->name);#else			  fprintf (stderr, _("\%s: option `--%s' doesn't allow an argument\n"),				   argv[0], pfound->name);#endif			}		      else			{			  /* +option or -option */#if defined _LIBC && defined USE_IN_LIBIO			  n = __asprintf (&buf, _("\%s: option `%c%s' doesn't allow an argument\n"),					  argv[0], argv[d->optind - 1][0],					  pfound->name);#else			  fprintf (stderr, _("\%s: option `%c%s' doesn't allow an argument\n"),				   argv[0], argv[d->optind - 1][0],				   pfound->name);#endif			}#if defined _LIBC && defined USE_IN_LIBIO		      if (n >= 0)			{			  _IO_flockfile (stderr);			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;			  ((_IO_FILE *) stderr)->_flags2			    |= _IO_FLAGS2_NOTCANCEL;			  if (_IO_fwide (stderr, 0) > 0)			    __fwprintf (stderr, L"%s", buf);			  else			    fputs (buf, stderr);			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;			  _IO_funlockfile (stderr);			  free (buf);			}#endif		    }		  d->__nextchar += strlen (d->__nextchar);		  d->optopt = pfound->val;		  return '?';		}	    }	  else if (pfound->has_arg == 1)	    {	      if (d->optind < argc)		d->optarg = argv[d->optind++];	      else		{		  if (print_errors)		    {#if defined _LIBC && defined USE_IN_LIBIO		      char *buf;		      if (__asprintf (&buf, _("\%s: option `%s' requires an argument\n"),				      argv[0], argv[d->optind - 1]) >= 0)			{			  _IO_flockfile (stderr);			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;			  ((_IO_FILE *) stderr)->_flags2			    |= _IO_FLAGS2_NOTCANCEL;			  if (_IO_fwide (stderr, 0) > 0)			    __fwprintf (stderr, L"%s", buf);			  else			    fputs (buf, stderr);			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;			  _IO_funlockfile (stderr);			  free (buf);			}#else		      fprintf (stderr,			       _("%s: option `%s' requires an argument\n"),			       argv[0], argv[d->optind - 1]);#endif		    }		  d->__nextchar += strlen (d->__nextchar);		  d->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 (!long_only || argv[d->optind][1] == '-'	  || strchr (optstring, *d->__nextchar) == NULL)	{	  if (print_errors)	    {#if defined _LIBC && defined USE_IN_LIBIO	      char *buf;	      int n;#endif	      if (argv[d->optind][1] == '-')		{		  /* --option */#if defined _LIBC && defined USE_IN_LIBIO		  n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"),				  argv[0], d->__nextchar);#else		  fprintf (stderr, _("%s: unrecognized option `--%s'\n"),			   argv[0], d->__nextchar);#endif		}	      else		{		  /* +option or -option */#if defined _LIBC && defined USE_IN_LIBIO		  n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"),				  argv[0], argv[d->optind][0], d->__nextchar);#else		  fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),			   argv[0], argv[d->optind][0], d->__nextchar);#endif		}#if defined _LIBC && defined USE_IN_LIBIO	      if (n >= 0)		{		  _IO_flockfile (stderr);		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;		  if (_IO_fwide (stderr, 0) > 0)		    __fwprintf (stderr, L"%s", buf);		  else		    fputs (buf, stderr);		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;		  _IO_funlockfile (stderr);		  free (buf);		}#endif	    }	  d->__nextchar = (char *) "";	  d->optind++;	  d->optopt = 0;	  return '?';	}    }  /* Look at and handle the next short option-character.  */  {    char c = *d->__nextchar++;    char *temp = strchr (optstring, c);    /* Increment `optind' when we start to process its last character.  */    if (*d->__nextchar == '\0')      ++d->optind;    if (temp == NULL || c == ':')      {	if (print_errors)	  {#if defined _LIBC && defined USE_IN_LIBIO	      char *buf;	      int n;#endif	    if (d->__posixly_correct)	      {		/* 1003.2 specifies the format of this message.  */#if defined _LIBC && defined USE_IN_LIBIO		n = __asprintf (&buf, _("%s: illegal option -- %c\n"),				argv[0], c);#else		fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);#endif	      }	    else	      {#if defined _LIBC && defined USE_IN_LIBIO		n = __asprintf (&buf, _("%s: invalid option -- %c\n"),				argv[0], c);#else		fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c);#endif	      }#if defined _LIBC && defined USE_IN_LIBIO	    if (n >= 0)	      {		_IO_flockfile (stderr);		int old_flags2 = ((_IO_FILE *) stderr)->_flags2;		((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;		if (_IO_fwide (stderr, 0) > 0)		  __fwprintf (stderr, L"%s", buf);		else		  fputs (buf, stderr);		((_IO_FILE *) stderr)->_flags2 = old_flags2;		_IO_funlockfile (stderr);		free (buf);