LCOV - code coverage report
Current view: top level - gl - getopt.c (source / functions) Hit Total Coverage
Test: GNU Libidn Lines: 226 280 80.7 %
Date: 2013-07-10 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 177 236 75.0 %

           Branch data     Line data    Source code
       1                 :            : /* Getopt for GNU.
       2                 :            :    NOTE: getopt is part of the C library, so if you don't know what
       3                 :            :    "Keep this file name-space clean" means, talk to drepper@gnu.org
       4                 :            :    before changing it!
       5                 :            :    Copyright (C) 1987-1996, 1998-2004, 2006, 2008-2013 Free Software
       6                 :            :    Foundation, Inc.
       7                 :            :    This file is part of the GNU C Library.
       8                 :            : 
       9                 :            :    This program is free software: you can redistribute it and/or modify
      10                 :            :    it under the terms of the GNU General Public License as published by
      11                 :            :    the Free Software Foundation; either version 3 of the License, or
      12                 :            :    (at your option) any later version.
      13                 :            : 
      14                 :            :    This program is distributed in the hope that it will be useful,
      15                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      16                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17                 :            :    GNU General Public License for more details.
      18                 :            : 
      19                 :            :    You should have received a copy of the GNU General Public License
      20                 :            :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #ifndef _LIBC
      23                 :            : # include <config.h>
      24                 :            : #endif
      25                 :            : 
      26                 :            : #include "getopt.h"
      27                 :            : 
      28                 :            : #include <stdio.h>
      29                 :            : #include <stdlib.h>
      30                 :            : #include <string.h>
      31                 :            : #include <unistd.h>
      32                 :            : 
      33                 :            : #ifdef _LIBC
      34                 :            : # include <libintl.h>
      35                 :            : #else
      36                 :            : # include "gettext.h"
      37                 :            : # define _(msgid) gettext (msgid)
      38                 :            : #endif
      39                 :            : 
      40                 :            : #if defined _LIBC && defined USE_IN_LIBIO
      41                 :            : # include <wchar.h>
      42                 :            : #endif
      43                 :            : 
      44                 :            : /* This version of 'getopt' appears to the caller like standard Unix 'getopt'
      45                 :            :    but it behaves differently for the user, since it allows the user
      46                 :            :    to intersperse the options with the other arguments.
      47                 :            : 
      48                 :            :    As 'getopt_long' works, it permutes the elements of ARGV so that,
      49                 :            :    when it is done, all the options precede everything else.  Thus
      50                 :            :    all application programs are extended to handle flexible argument order.
      51                 :            : 
      52                 :            :    Using 'getopt' or setting the environment variable POSIXLY_CORRECT
      53                 :            :    disables permutation.
      54                 :            :    Then the behavior is completely standard.
      55                 :            : 
      56                 :            :    GNU application programs can use a third alternative mode in which
      57                 :            :    they can distinguish the relative order of options and other arguments.  */
      58                 :            : 
      59                 :            : #include "getopt_int.h"
      60                 :            : 
      61                 :            : /* For communication from 'getopt' to the caller.
      62                 :            :    When 'getopt' finds an option that takes an argument,
      63                 :            :    the argument value is returned here.
      64                 :            :    Also, when 'ordering' is RETURN_IN_ORDER,
      65                 :            :    each non-option ARGV-element is returned here.  */
      66                 :            : 
      67                 :            : char *optarg;
      68                 :            : 
      69                 :            : /* Index in ARGV of the next element to be scanned.
      70                 :            :    This is used for communication to and from the caller
      71                 :            :    and for communication between successive calls to 'getopt'.
      72                 :            : 
      73                 :            :    On entry to 'getopt', zero means this is the first call; initialize.
      74                 :            : 
      75                 :            :    When 'getopt' returns -1, this is the index of the first of the
      76                 :            :    non-option elements that the caller should itself scan.
      77                 :            : 
      78                 :            :    Otherwise, 'optind' communicates from one call to the next
      79                 :            :    how much of ARGV has been scanned so far.  */
      80                 :            : 
      81                 :            : /* 1003.2 says this must be 1 before any call.  */
      82                 :            : int optind = 1;
      83                 :            : 
      84                 :            : /* Callers store zero here to inhibit the error message
      85                 :            :    for unrecognized options.  */
      86                 :            : 
      87                 :            : int opterr = 1;
      88                 :            : 
      89                 :            : /* Set to an option character which was unrecognized.
      90                 :            :    This must be initialized on some systems to avoid linking in the
      91                 :            :    system's own getopt implementation.  */
      92                 :            : 
      93                 :            : int optopt = '?';
      94                 :            : 
      95                 :            : /* Keep a global copy of all internal members of getopt_data.  */
      96                 :            : 
      97                 :            : static struct _getopt_data getopt_data;
      98                 :            : 
      99                 :            : 
     100                 :            : #if defined HAVE_DECL_GETENV && !HAVE_DECL_GETENV
     101                 :            : extern char *getenv ();
     102                 :            : #endif
     103                 :            : 
     104                 :            : #ifdef _LIBC
     105                 :            : /* Stored original parameters.
     106                 :            :    XXX This is no good solution.  We should rather copy the args so
     107                 :            :    that we can compare them later.  But we must not use malloc(3).  */
     108                 :            : extern int __libc_argc;
     109                 :            : extern char **__libc_argv;
     110                 :            : 
     111                 :            : /* Bash 2.0 gives us an environment variable containing flags
     112                 :            :    indicating ARGV elements that should not be considered arguments.  */
     113                 :            : 
     114                 :            : # ifdef USE_NONOPTION_FLAGS
     115                 :            : /* Defined in getopt_init.c  */
     116                 :            : extern char *__getopt_nonoption_flags;
     117                 :            : # endif
     118                 :            : 
     119                 :            : # ifdef USE_NONOPTION_FLAGS
     120                 :            : #  define SWAP_FLAGS(ch1, ch2) \
     121                 :            :   if (d->__nonoption_flags_len > 0)                                           \
     122                 :            :     {                                                                         \
     123                 :            :       char __tmp = __getopt_nonoption_flags[ch1];                             \
     124                 :            :       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
     125                 :            :       __getopt_nonoption_flags[ch2] = __tmp;                                  \
     126                 :            :     }
     127                 :            : # else
     128                 :            : #  define SWAP_FLAGS(ch1, ch2)
     129                 :            : # endif
     130                 :            : #else   /* !_LIBC */
     131                 :            : # define SWAP_FLAGS(ch1, ch2)
     132                 :            : #endif  /* _LIBC */
     133                 :            : 
     134                 :            : /* Exchange two adjacent subsequences of ARGV.
     135                 :            :    One subsequence is elements [first_nonopt,last_nonopt)
     136                 :            :    which contains all the non-options that have been skipped so far.
     137                 :            :    The other is elements [last_nonopt,optind), which contains all
     138                 :            :    the options processed since those non-options were skipped.
     139                 :            : 
     140                 :            :    'first_nonopt' and 'last_nonopt' are relocated so that they describe
     141                 :            :    the new indices of the non-options in ARGV after they are moved.  */
     142                 :            : 
     143                 :            : static void
     144                 :         18 : exchange (char **argv, struct _getopt_data *d)
     145                 :            : {
     146                 :         18 :   int bottom = d->__first_nonopt;
     147                 :         18 :   int middle = d->__last_nonopt;
     148                 :         18 :   int top = d->optind;
     149                 :            :   char *tem;
     150                 :            : 
     151                 :            :   /* Exchange the shorter segment with the far end of the longer segment.
     152                 :            :      That puts the shorter segment into the right place.
     153                 :            :      It leaves the longer segment in the right place overall,
     154                 :            :      but it consists of two parts that need to be swapped next.  */
     155                 :            : 
     156                 :            : #if defined _LIBC && defined USE_NONOPTION_FLAGS
     157                 :            :   /* First make sure the handling of the '__getopt_nonoption_flags'
     158                 :            :      string can work normally.  Our top argument must be in the range
     159                 :            :      of the string.  */
     160                 :            :   if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
     161                 :            :     {
     162                 :            :       /* We must extend the array.  The user plays games with us and
     163                 :            :          presents new arguments.  */
     164                 :            :       char *new_str = malloc (top + 1);
     165                 :            :       if (new_str == NULL)
     166                 :            :         d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
     167                 :            :       else
     168                 :            :         {
     169                 :            :           memset (__mempcpy (new_str, __getopt_nonoption_flags,
     170                 :            :                              d->__nonoption_flags_max_len),
     171                 :            :                   '\0', top + 1 - d->__nonoption_flags_max_len);
     172                 :            :           d->__nonoption_flags_max_len = top + 1;
     173                 :            :           __getopt_nonoption_flags = new_str;
     174                 :            :         }
     175                 :            :     }
     176                 :            : #endif
     177                 :            : 
     178 [ +  - ][ +  + ]:         54 :   while (top > middle && middle > bottom)
     179                 :            :     {
     180         [ +  + ]:         36 :       if (top - middle > middle - bottom)
     181                 :            :         {
     182                 :            :           /* Bottom segment is the short one.  */
     183                 :          8 :           int len = middle - bottom;
     184                 :            :           register int i;
     185                 :            : 
     186                 :            :           /* Swap it with the top part of the top segment.  */
     187         [ +  + ]:         16 :           for (i = 0; i < len; i++)
     188                 :            :             {
     189                 :          8 :               tem = argv[bottom + i];
     190                 :          8 :               argv[bottom + i] = argv[top - (middle - bottom) + i];
     191                 :          8 :               argv[top - (middle - bottom) + i] = tem;
     192                 :            :               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
     193                 :            :             }
     194                 :            :           /* Exclude the moved bottom segment from further swapping.  */
     195                 :          8 :           top -= len;
     196                 :            :         }
     197                 :            :       else
     198                 :            :         {
     199                 :            :           /* Top segment is the short one.  */
     200                 :         28 :           int len = top - middle;
     201                 :            :           register int i;
     202                 :            : 
     203                 :            :           /* Swap it with the bottom part of the bottom segment.  */
     204         [ +  + ]:         56 :           for (i = 0; i < len; i++)
     205                 :            :             {
     206                 :         28 :               tem = argv[bottom + i];
     207                 :         28 :               argv[bottom + i] = argv[middle + i];
     208                 :         28 :               argv[middle + i] = tem;
     209                 :            :               SWAP_FLAGS (bottom + i, middle + i);
     210                 :            :             }
     211                 :            :           /* Exclude the moved top segment from further swapping.  */
     212                 :         28 :           bottom += len;
     213                 :            :         }
     214                 :            :     }
     215                 :            : 
     216                 :            :   /* Update records for the slots the non-options now occupy.  */
     217                 :            : 
     218                 :         18 :   d->__first_nonopt += (d->optind - d->__last_nonopt);
     219                 :         18 :   d->__last_nonopt = d->optind;
     220                 :         18 : }
     221                 :            : 
     222                 :            : /* Initialize the internal data when the first call is made.  */
     223                 :            : 
     224                 :            : static const char *
     225                 :        111 : _getopt_initialize (int argc _GL_UNUSED,
     226                 :            :                     char **argv _GL_UNUSED, const char *optstring,
     227                 :            :                     struct _getopt_data *d, int posixly_correct)
     228                 :            : {
     229                 :            :   /* Start processing options with ARGV-element 1 (since ARGV-element 0
     230                 :            :      is the program name); the sequence of previously skipped
     231                 :            :      non-option ARGV-elements is empty.  */
     232                 :            : 
     233                 :        111 :   d->__first_nonopt = d->__last_nonopt = d->optind;
     234                 :            : 
     235                 :        111 :   d->__nextchar = NULL;
     236                 :            : 
     237 [ +  + ][ +  + ]:        111 :   d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
     238                 :            : 
     239                 :            :   /* Determine how to handle the ordering of options and nonoptions.  */
     240                 :            : 
     241         [ +  + ]:        111 :   if (optstring[0] == '-')
     242                 :            :     {
     243                 :          7 :       d->__ordering = RETURN_IN_ORDER;
     244                 :          7 :       ++optstring;
     245                 :            :     }
     246         [ +  + ]:        104 :   else if (optstring[0] == '+')
     247                 :            :     {
     248                 :         15 :       d->__ordering = REQUIRE_ORDER;
     249                 :         15 :       ++optstring;
     250                 :            :     }
     251         [ +  + ]:         89 :   else if (d->__posixly_correct)
     252                 :         50 :     d->__ordering = REQUIRE_ORDER;
     253                 :            :   else
     254                 :         39 :     d->__ordering = PERMUTE;
     255                 :            : 
     256                 :            : #if defined _LIBC && defined USE_NONOPTION_FLAGS
     257                 :            :   if (!d->__posixly_correct
     258                 :            :       && argc == __libc_argc && argv == __libc_argv)
     259                 :            :     {
     260                 :            :       if (d->__nonoption_flags_max_len == 0)
     261                 :            :         {
     262                 :            :           if (__getopt_nonoption_flags == NULL
     263                 :            :               || __getopt_nonoption_flags[0] == '\0')
     264                 :            :             d->__nonoption_flags_max_len = -1;
     265                 :            :           else
     266                 :            :             {
     267                 :            :               const char *orig_str = __getopt_nonoption_flags;
     268                 :            :               int len = d->__nonoption_flags_max_len = strlen (orig_str);
     269                 :            :               if (d->__nonoption_flags_max_len < argc)
     270                 :            :                 d->__nonoption_flags_max_len = argc;
     271                 :            :               __getopt_nonoption_flags =
     272                 :            :                 (char *) malloc (d->__nonoption_flags_max_len);
     273                 :            :               if (__getopt_nonoption_flags == NULL)
     274                 :            :                 d->__nonoption_flags_max_len = -1;
     275                 :            :               else
     276                 :            :                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
     277                 :            :                         '\0', d->__nonoption_flags_max_len - len);
     278                 :            :             }
     279                 :            :         }
     280                 :            :       d->__nonoption_flags_len = d->__nonoption_flags_max_len;
     281                 :            :     }
     282                 :            :   else
     283                 :            :     d->__nonoption_flags_len = 0;
     284                 :            : #endif
     285                 :            : 
     286                 :        111 :   return optstring;
     287                 :            : }
     288                 :            : 
     289                 :            : /* Scan elements of ARGV (whose length is ARGC) for option characters
     290                 :            :    given in OPTSTRING.
     291                 :            : 
     292                 :            :    If an element of ARGV starts with '-', and is not exactly "-" or "--",
     293                 :            :    then it is an option element.  The characters of this element
     294                 :            :    (aside from the initial '-') are option characters.  If 'getopt'
     295                 :            :    is called repeatedly, it returns successively each of the option characters
     296                 :            :    from each of the option elements.
     297                 :            : 
     298                 :            :    If 'getopt' finds another option character, it returns that character,
     299                 :            :    updating 'optind' and 'nextchar' so that the next call to 'getopt' can
     300                 :            :    resume the scan with the following option character or ARGV-element.
     301                 :            : 
     302                 :            :    If there are no more option characters, 'getopt' returns -1.
     303                 :            :    Then 'optind' is the index in ARGV of the first ARGV-element
     304                 :            :    that is not an option.  (The ARGV-elements have been permuted
     305                 :            :    so that those that are not options now come last.)
     306                 :            : 
     307                 :            :    OPTSTRING is a string containing the legitimate option characters.
     308                 :            :    If an option character is seen that is not listed in OPTSTRING,
     309                 :            :    return '?' after printing an error message.  If you set 'opterr' to
     310                 :            :    zero, the error message is suppressed but we still return '?'.
     311                 :            : 
     312                 :            :    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
     313                 :            :    so the following text in the same ARGV-element, or the text of the following
     314                 :            :    ARGV-element, is returned in 'optarg'.  Two colons mean an option that
     315                 :            :    wants an optional arg; if there is text in the current ARGV-element,
     316                 :            :    it is returned in 'optarg', otherwise 'optarg' is set to zero.
     317                 :            : 
     318                 :            :    If OPTSTRING starts with '-' or '+', it requests different methods of
     319                 :            :    handling the non-option ARGV-elements.
     320                 :            :    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
     321                 :            : 
     322                 :            :    Long-named options begin with '--' instead of '-'.
     323                 :            :    Their names may be abbreviated as long as the abbreviation is unique
     324                 :            :    or is an exact match for some defined option.  If they have an
     325                 :            :    argument, it follows the option name in the same ARGV-element, separated
     326                 :            :    from the option name by a '=', or else the in next ARGV-element.
     327                 :            :    When 'getopt' finds a long-named option, it returns 0 if that option's
     328                 :            :    'flag' field is nonzero, the value of the option's 'val' field
     329                 :            :    if the 'flag' field is zero.
     330                 :            : 
     331                 :            :    The elements of ARGV aren't really const, because we permute them.
     332                 :            :    But we pretend they're const in the prototype to be compatible
     333                 :            :    with other systems.
     334                 :            : 
     335                 :            :    LONGOPTS is a vector of 'struct option' terminated by an
     336                 :            :    element containing a name which is zero.
     337                 :            : 
     338                 :            :    LONGIND returns the index in LONGOPT of the long-named option found.
     339                 :            :    It is only valid when a long-named option has been found by the most
     340                 :            :    recent call.
     341                 :            : 
     342                 :            :    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
     343                 :            :    long-named options.  */
     344                 :            : 
     345                 :            : int
     346                 :        641 : _getopt_internal_r (int argc, char **argv, const char *optstring,
     347                 :            :                     const struct option *longopts, int *longind,
     348                 :            :                     int long_only, struct _getopt_data *d, int posixly_correct)
     349                 :            : {
     350                 :        641 :   int print_errors = d->opterr;
     351                 :            : 
     352         [ -  + ]:        641 :   if (argc < 1)
     353                 :          0 :     return -1;
     354                 :            : 
     355                 :        641 :   d->optarg = NULL;
     356                 :            : 
     357 [ +  + ][ -  + ]:        641 :   if (d->optind == 0 || !d->__initialized)
     358                 :            :     {
     359         [ +  - ]:        111 :       if (d->optind == 0)
     360                 :        111 :         d->optind = 1;  /* Don't scan ARGV[0], the program name.  */
     361                 :        111 :       optstring = _getopt_initialize (argc, argv, optstring, d,
     362                 :            :                                       posixly_correct);
     363                 :        111 :       d->__initialized = 1;
     364                 :            :     }
     365 [ +  + ][ +  + ]:        530 :   else if (optstring[0] == '-' || optstring[0] == '+')
     366                 :        100 :     optstring++;
     367         [ +  + ]:        641 :   if (optstring[0] == ':')
     368                 :         68 :     print_errors = 0;
     369                 :            : 
     370                 :            :   /* Test whether ARGV[optind] points to a non-option argument.
     371                 :            :      Either it does not have option syntax, or there is an environment flag
     372                 :            :      from the shell indicating it is not an option.  The later information
     373                 :            :      is only used when the used in the GNU libc.  */
     374                 :            : #if defined _LIBC && defined USE_NONOPTION_FLAGS
     375                 :            : # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
     376                 :            :                       || (d->optind < d->__nonoption_flags_len                \
     377                 :            :                           && __getopt_nonoption_flags[d->optind] == '1'))
     378                 :            : #else
     379                 :            : # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
     380                 :            : #endif
     381                 :            : 
     382 [ +  + ][ +  + ]:        641 :   if (d->__nextchar == NULL || *d->__nextchar == '\0')
     383                 :            :     {
     384                 :            :       /* Advance to the next ARGV-element.  */
     385                 :            : 
     386                 :            :       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
     387                 :            :          moved back by the user (who may also have changed the arguments).  */
     388         [ +  + ]:        607 :       if (d->__last_nonopt > d->optind)
     389                 :         43 :         d->__last_nonopt = d->optind;
     390         [ +  + ]:        607 :       if (d->__first_nonopt > d->optind)
     391                 :         43 :         d->__first_nonopt = d->optind;
     392                 :            : 
     393         [ +  + ]:        607 :       if (d->__ordering == PERMUTE)
     394                 :            :         {
     395                 :            :           /* If we have just processed some options following some non-options,
     396                 :            :              exchange them so that the options come first.  */
     397                 :            : 
     398         [ +  + ]:        226 :           if (d->__first_nonopt != d->__last_nonopt
     399         [ +  - ]:         16 :               && d->__last_nonopt != d->optind)
     400                 :         16 :             exchange ((char **) argv, d);
     401         [ +  + ]:        210 :           else if (d->__last_nonopt != d->optind)
     402                 :        120 :             d->__first_nonopt = d->optind;
     403                 :            : 
     404                 :            :           /* Skip any additional non-options
     405                 :            :              and extend the range of non-options previously skipped.  */
     406                 :            : 
     407 [ +  + ][ +  + ]:        350 :           while (d->optind < argc && NONOPTION_P)
                 [ -  + ]
     408                 :        124 :             d->optind++;
     409                 :        226 :           d->__last_nonopt = d->optind;
     410                 :            :         }
     411                 :            : 
     412                 :            :       /* The special ARGV-element '--' means premature end of options.
     413                 :            :          Skip it like a null option,
     414                 :            :          then exchange with previous non-options as if it were an option,
     415                 :            :          then skip everything else like a non-option.  */
     416                 :            : 
     417 [ +  + ][ +  + ]:        607 :       if (d->optind != argc && !strcmp (argv[d->optind], "--"))
     418                 :            :         {
     419                 :          8 :           d->optind++;
     420                 :            : 
     421         [ +  + ]:          8 :           if (d->__first_nonopt != d->__last_nonopt
     422         [ +  - ]:          2 :               && d->__last_nonopt != d->optind)
     423                 :          2 :             exchange ((char **) argv, d);
     424         [ +  - ]:          6 :           else if (d->__first_nonopt == d->__last_nonopt)
     425                 :          6 :             d->__first_nonopt = d->optind;
     426                 :          8 :           d->__last_nonopt = argc;
     427                 :            : 
     428                 :          8 :           d->optind = argc;
     429                 :            :         }
     430                 :            : 
     431                 :            :       /* If we have done all the ARGV-elements, stop the scan
     432                 :            :          and back over any non-options that we skipped and permuted.  */
     433                 :            : 
     434         [ +  + ]:        607 :       if (d->optind == argc)
     435                 :            :         {
     436                 :            :           /* Set the next-arg-index to point at the non-options
     437                 :            :              that we previously skipped, so the caller will digest them.  */
     438         [ +  + ]:        118 :           if (d->__first_nonopt != d->__last_nonopt)
     439                 :         84 :             d->optind = d->__first_nonopt;
     440                 :        118 :           return -1;
     441                 :            :         }
     442                 :            : 
     443                 :            :       /* If we have come to a non-option and did not permute it,
     444                 :            :          either stop the scan or describe it to the caller and pass it by.  */
     445                 :            : 
     446 [ +  + ][ -  + ]:        489 :       if (NONOPTION_P)
     447                 :            :         {
     448         [ +  + ]:        132 :           if (d->__ordering == REQUIRE_ORDER)
     449                 :        100 :             return -1;
     450                 :         32 :           d->optarg = argv[d->optind++];
     451                 :         32 :           return 1;
     452                 :            :         }
     453                 :            : 
     454                 :            :       /* We have found another option-ARGV-element.
     455                 :            :          Skip the initial punctuation.  */
     456                 :            : 
     457                 :        357 :       d->__nextchar = (argv[d->optind] + 1
     458 [ +  + ][ +  + ]:        357 :                   + (longopts != NULL && argv[d->optind][1] == '-'));
     459                 :            :     }
     460                 :            : 
     461                 :            :   /* Decode the current option-ARGV-element.  */
     462                 :            : 
     463                 :            :   /* Check whether the ARGV-element is a long option.
     464                 :            : 
     465                 :            :      If long_only and the ARGV-element has the form "-f", where f is
     466                 :            :      a valid short option, don't consider it an abbreviated form of
     467                 :            :      a long option that starts with f.  Otherwise there would be no
     468                 :            :      way to give the -f short option.
     469                 :            : 
     470                 :            :      On the other hand, if there's a long option "fubar" and
     471                 :            :      the ARGV-element is "-fu", do consider that an abbreviation of
     472                 :            :      the long option, just like "--fu", and not "-f" with arg "u".
     473                 :            : 
     474                 :            :      This distinction seems to be the most useful approach.  */
     475                 :            : 
     476         [ +  + ]:        391 :   if (longopts != NULL
     477         [ +  + ]:        186 :       && (argv[d->optind][1] == '-'
     478 [ +  + ][ +  + ]:        141 :           || (long_only && (argv[d->optind][2]
     479         [ +  + ]:          3 :                             || !strchr (optstring, argv[d->optind][1])))))
     480                 :            :     {
     481                 :            :       char *nameend;
     482                 :            :       unsigned int namelen;
     483                 :            :       const struct option *p;
     484                 :         53 :       const struct option *pfound = NULL;
     485                 :            :       struct option_list
     486                 :            :       {
     487                 :            :         const struct option *p;
     488                 :            :         struct option_list *next;
     489                 :         53 :       } *ambig_list = NULL;
     490                 :         53 :       int exact = 0;
     491                 :         53 :       int indfound = -1;
     492                 :            :       int option_index;
     493                 :            : 
     494 [ +  + ][ +  + ]:        213 :       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
     495                 :            :         /* Do nothing.  */ ;
     496                 :         53 :       namelen = nameend - d->__nextchar;
     497                 :            : 
     498                 :            :       /* Test all long options for either exact match
     499                 :            :          or abbreviated matches.  */
     500         [ +  + ]:        328 :       for (p = longopts, option_index = 0; p->name; p++, option_index++)
     501         [ +  + ]:        294 :         if (!strncmp (p->name, d->__nextchar, namelen))
     502                 :            :           {
     503         [ +  + ]:         83 :             if (namelen == (unsigned int) strlen (p->name))
     504                 :            :               {
     505                 :            :                 /* Exact match found.  */
     506                 :         19 :                 pfound = p;
     507                 :         19 :                 indfound = option_index;
     508                 :         19 :                 exact = 1;
     509                 :         19 :                 break;
     510                 :            :               }
     511         [ +  + ]:         64 :             else if (pfound == NULL)
     512                 :            :               {
     513                 :            :                 /* First nonexact match found.  */
     514                 :         36 :                 pfound = p;
     515                 :         36 :                 indfound = option_index;
     516                 :            :               }
     517         [ +  + ]:         28 :             else if (long_only
     518         [ +  - ]:         14 :                      || pfound->has_arg != p->has_arg
     519         [ +  - ]:         14 :                      || pfound->flag != p->flag
     520         [ +  + ]:         14 :                      || pfound->val != p->val)
     521                 :            :               {
     522                 :            :                 /* Second or later nonexact match found.  */
     523                 :         22 :                 struct option_list *newp = malloc (sizeof (*newp));
     524                 :         22 :                 newp->p = p;
     525                 :         22 :                 newp->next = ambig_list;
     526                 :         22 :                 ambig_list = newp;
     527                 :            :               }
     528                 :            :           }
     529                 :            : 
     530 [ +  + ][ +  - ]:         53 :       if (ambig_list != NULL && !exact)
     531                 :            :         {
     532         [ -  + ]:         11 :           if (print_errors)
     533                 :            :             {
     534                 :            :               struct option_list first;
     535                 :          0 :               first.p = pfound;
     536                 :          0 :               first.next = ambig_list;
     537                 :          0 :               ambig_list = &first;
     538                 :            : 
     539                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     540                 :            :               char *buf = NULL;
     541                 :            :               size_t buflen = 0;
     542                 :            : 
     543                 :            :               FILE *fp = open_memstream (&buf, &buflen);
     544                 :            :               if (fp != NULL)
     545                 :            :                 {
     546                 :            :                   fprintf (fp,
     547                 :            :                            _("%s: option '%s' is ambiguous; possibilities:"),
     548                 :            :                            argv[0], argv[d->optind]);
     549                 :            : 
     550                 :            :                   do
     551                 :            :                     {
     552                 :            :                       fprintf (fp, " '--%s'", ambig_list->p->name);
     553                 :            :                       ambig_list = ambig_list->next;
     554                 :            :                     }
     555                 :            :                   while (ambig_list != NULL);
     556                 :            : 
     557                 :            :                   fputc_unlocked ('\n', fp);
     558                 :            : 
     559                 :            :                   if (__builtin_expect (fclose (fp) != EOF, 1))
     560                 :            :                     {
     561                 :            :                       _IO_flockfile (stderr);
     562                 :            : 
     563                 :            :                       int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     564                 :            :                       ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
     565                 :            : 
     566                 :            :                       __fxprintf (NULL, "%s", buf);
     567                 :            : 
     568                 :            :                       ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     569                 :            :                       _IO_funlockfile (stderr);
     570                 :            : 
     571                 :            :                       free (buf);
     572                 :            :                     }
     573                 :            :                 }
     574                 :            : #else
     575                 :          0 :               fprintf (stderr,
     576                 :          0 :                        _("%s: option '%s' is ambiguous; possibilities:"),
     577                 :          0 :                        argv[0], argv[d->optind]);
     578                 :            :               do
     579                 :            :                 {
     580                 :          0 :                   fprintf (stderr, " '--%s'", ambig_list->p->name);
     581                 :          0 :                   ambig_list = ambig_list->next;
     582                 :            :                 }
     583         [ #  # ]:          0 :               while (ambig_list != NULL);
     584                 :            : 
     585                 :          0 :               fputc ('\n', stderr);
     586                 :            : #endif
     587                 :            :             }
     588                 :         11 :           d->__nextchar += strlen (d->__nextchar);
     589                 :         11 :           d->optind++;
     590                 :         11 :           d->optopt = 0;
     591                 :         11 :           return '?';
     592                 :            :         }
     593                 :            : 
     594         [ -  + ]:         42 :       while (ambig_list != NULL)
     595                 :            :         {
     596                 :          0 :           struct option_list *pn = ambig_list->next;
     597                 :          0 :           free (ambig_list);
     598                 :          0 :           ambig_list = pn;
     599                 :            :         }
     600                 :            : 
     601         [ +  + ]:         42 :       if (pfound != NULL)
     602                 :            :         {
     603                 :         41 :           option_index = indfound;
     604                 :         41 :           d->optind++;
     605         [ +  + ]:         41 :           if (*nameend)
     606                 :            :             {
     607                 :            :               /* Don't test has_arg with >, because some C compilers don't
     608                 :            :                  allow it to be used on enums.  */
     609         [ +  + ]:         12 :               if (pfound->has_arg)
     610                 :          8 :                 d->optarg = nameend + 1;
     611                 :            :               else
     612                 :            :                 {
     613         [ -  + ]:          4 :                   if (print_errors)
     614                 :            :                     {
     615                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     616                 :            :                       char *buf;
     617                 :            :                       int n;
     618                 :            : #endif
     619                 :            : 
     620         [ #  # ]:          0 :                       if (argv[d->optind - 1][1] == '-')
     621                 :            :                         {
     622                 :            :                           /* --option */
     623                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     624                 :            :                           n = __asprintf (&buf, _("\
     625                 :            : %s: option '--%s' doesn't allow an argument\n"),
     626                 :            :                                           argv[0], pfound->name);
     627                 :            : #else
     628                 :          0 :                           fprintf (stderr, _("\
     629                 :            : %s: option '--%s' doesn't allow an argument\n"),
     630                 :            :                                    argv[0], pfound->name);
     631                 :            : #endif
     632                 :            :                         }
     633                 :            :                       else
     634                 :            :                         {
     635                 :            :                           /* +option or -option */
     636                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     637                 :            :                           n = __asprintf (&buf, _("\
     638                 :            : %s: option '%c%s' doesn't allow an argument\n"),
     639                 :            :                                           argv[0], argv[d->optind - 1][0],
     640                 :            :                                           pfound->name);
     641                 :            : #else
     642                 :          0 :                           fprintf (stderr, _("\
     643                 :            : %s: option '%c%s' doesn't allow an argument\n"),
     644                 :          0 :                                    argv[0], argv[d->optind - 1][0],
     645                 :            :                                    pfound->name);
     646                 :            : #endif
     647                 :            :                         }
     648                 :            : 
     649                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     650                 :            :                       if (n >= 0)
     651                 :            :                         {
     652                 :            :                           _IO_flockfile (stderr);
     653                 :            : 
     654                 :            :                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     655                 :            :                           ((_IO_FILE *) stderr)->_flags2
     656                 :            :                             |= _IO_FLAGS2_NOTCANCEL;
     657                 :            : 
     658                 :            :                           __fxprintf (NULL, "%s", buf);
     659                 :            : 
     660                 :            :                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     661                 :            :                           _IO_funlockfile (stderr);
     662                 :            : 
     663                 :            :                           free (buf);
     664                 :            :                         }
     665                 :            : #endif
     666                 :            :                     }
     667                 :            : 
     668                 :          4 :                   d->__nextchar += strlen (d->__nextchar);
     669                 :            : 
     670                 :          4 :                   d->optopt = pfound->val;
     671                 :          4 :                   return '?';
     672                 :            :                 }
     673                 :            :             }
     674         [ +  + ]:         29 :           else if (pfound->has_arg == 1)
     675                 :            :             {
     676         [ +  - ]:          4 :               if (d->optind < argc)
     677                 :          4 :                 d->optarg = argv[d->optind++];
     678                 :            :               else
     679                 :            :                 {
     680         [ #  # ]:          0 :                   if (print_errors)
     681                 :            :                     {
     682                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     683                 :            :                       char *buf;
     684                 :            : 
     685                 :            :                       if (__asprintf (&buf, _("\
     686                 :            : %s: option '--%s' requires an argument\n"),
     687                 :            :                                       argv[0], pfound->name) >= 0)
     688                 :            :                         {
     689                 :            :                           _IO_flockfile (stderr);
     690                 :            : 
     691                 :            :                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     692                 :            :                           ((_IO_FILE *) stderr)->_flags2
     693                 :            :                             |= _IO_FLAGS2_NOTCANCEL;
     694                 :            : 
     695                 :            :                           __fxprintf (NULL, "%s", buf);
     696                 :            : 
     697                 :            :                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     698                 :            :                           _IO_funlockfile (stderr);
     699                 :            : 
     700                 :            :                           free (buf);
     701                 :            :                         }
     702                 :            : #else
     703                 :          0 :                       fprintf (stderr,
     704                 :          0 :                                _("%s: option '--%s' requires an argument\n"),
     705                 :            :                                argv[0], pfound->name);
     706                 :            : #endif
     707                 :            :                     }
     708                 :          0 :                   d->__nextchar += strlen (d->__nextchar);
     709                 :          0 :                   d->optopt = pfound->val;
     710         [ #  # ]:          0 :                   return optstring[0] == ':' ? ':' : '?';
     711                 :            :                 }
     712                 :            :             }
     713                 :         37 :           d->__nextchar += strlen (d->__nextchar);
     714         [ +  - ]:         37 :           if (longind != NULL)
     715                 :         37 :             *longind = option_index;
     716         [ +  + ]:         37 :           if (pfound->flag)
     717                 :            :             {
     718                 :          9 :               *(pfound->flag) = pfound->val;
     719                 :          9 :               return 0;
     720                 :            :             }
     721                 :         28 :           return pfound->val;
     722                 :            :         }
     723                 :            : 
     724                 :            :       /* Can't find it as a long option.  If this is not getopt_long_only,
     725                 :            :          or the option starts with '--' or is not a valid short
     726                 :            :          option, then it's an error.
     727                 :            :          Otherwise interpret it as a short option.  */
     728 [ +  - ][ +  - ]:          1 :       if (!long_only || argv[d->optind][1] == '-'
     729         [ -  + ]:          1 :           || strchr (optstring, *d->__nextchar) == NULL)
     730                 :            :         {
     731         [ #  # ]:          0 :           if (print_errors)
     732                 :            :             {
     733                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     734                 :            :               char *buf;
     735                 :            :               int n;
     736                 :            : #endif
     737                 :            : 
     738         [ #  # ]:          0 :               if (argv[d->optind][1] == '-')
     739                 :            :                 {
     740                 :            :                   /* --option */
     741                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     742                 :            :                   n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
     743                 :            :                                   argv[0], d->__nextchar);
     744                 :            : #else
     745                 :          0 :                   fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
     746                 :            :                            argv[0], d->__nextchar);
     747                 :            : #endif
     748                 :            :                 }
     749                 :            :               else
     750                 :            :                 {
     751                 :            :                   /* +option or -option */
     752                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     753                 :            :                   n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
     754                 :            :                                   argv[0], argv[d->optind][0], d->__nextchar);
     755                 :            : #else
     756                 :          0 :                   fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
     757                 :          0 :                            argv[0], argv[d->optind][0], d->__nextchar);
     758                 :            : #endif
     759                 :            :                 }
     760                 :            : 
     761                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     762                 :            :               if (n >= 0)
     763                 :            :                 {
     764                 :            :                   _IO_flockfile (stderr);
     765                 :            : 
     766                 :            :                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     767                 :            :                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
     768                 :            : 
     769                 :            :                   __fxprintf (NULL, "%s", buf);
     770                 :            : 
     771                 :            :                   ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     772                 :            :                   _IO_funlockfile (stderr);
     773                 :            : 
     774                 :            :                   free (buf);
     775                 :            :                 }
     776                 :            : #endif
     777                 :            :             }
     778                 :          0 :           d->__nextchar = (char *) "";
     779                 :          0 :           d->optind++;
     780                 :          0 :           d->optopt = 0;
     781                 :          0 :           return '?';
     782                 :            :         }
     783                 :            :     }
     784                 :            : 
     785                 :            :   /* Look at and handle the next short option-character.  */
     786                 :            : 
     787                 :            :   {
     788                 :        339 :     char c = *d->__nextchar++;
     789                 :        339 :     const char *temp = strchr (optstring, c);
     790                 :            : 
     791                 :            :     /* Increment 'optind' when we start to process its last character.  */
     792         [ +  + ]:        339 :     if (*d->__nextchar == '\0')
     793                 :        265 :       ++d->optind;
     794                 :            : 
     795 [ +  + ][ +  + ]:        339 :     if (temp == NULL || c == ':' || c == ';')
                 [ -  + ]
     796                 :            :       {
     797         [ +  + ]:         34 :         if (print_errors)
     798                 :            :           {
     799                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     800                 :            :               char *buf;
     801                 :            :               int n;
     802                 :            : #endif
     803                 :            : 
     804                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     805                 :            :               n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
     806                 :            :                               argv[0], c);
     807                 :            : #else
     808                 :         12 :               fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
     809                 :            : #endif
     810                 :            : 
     811                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     812                 :            :             if (n >= 0)
     813                 :            :               {
     814                 :            :                 _IO_flockfile (stderr);
     815                 :            : 
     816                 :            :                 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     817                 :            :                 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
     818                 :            : 
     819                 :            :                 __fxprintf (NULL, "%s", buf);
     820                 :            : 
     821                 :            :                 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     822                 :            :                 _IO_funlockfile (stderr);
     823                 :            : 
     824                 :            :                 free (buf);
     825                 :            :               }
     826                 :            : #endif
     827                 :            :           }
     828                 :         34 :         d->optopt = c;
     829                 :         34 :         return '?';
     830                 :            :       }
     831                 :            :     /* Convenience. Treat POSIX -W foo same as long option --foo */
     832 [ +  + ][ +  - ]:        305 :     if (temp[0] == 'W' && temp[1] == ';')
     833                 :            :       {
     834                 :            :         char *nameend;
     835                 :            :         const struct option *p;
     836                 :         40 :         const struct option *pfound = NULL;
     837                 :         40 :         int exact = 0;
     838                 :         40 :         int ambig = 0;
     839                 :         40 :         int indfound = 0;
     840                 :            :         int option_index;
     841                 :            : 
     842         [ +  + ]:         40 :         if (longopts == NULL)
     843                 :          5 :           goto no_longs;
     844                 :            : 
     845                 :            :         /* This is an option that requires an argument.  */
     846         [ +  + ]:         35 :         if (*d->__nextchar != '\0')
     847                 :            :           {
     848                 :         21 :             d->optarg = d->__nextchar;
     849                 :            :             /* If we end this ARGV-element by taking the rest as an arg,
     850                 :            :                we must advance to the next element now.  */
     851                 :         21 :             d->optind++;
     852                 :            :           }
     853         [ +  + ]:         14 :         else if (d->optind == argc)
     854                 :            :           {
     855         [ -  + ]:          1 :             if (print_errors)
     856                 :            :               {
     857                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     858                 :            :                 char *buf;
     859                 :            : 
     860                 :            :                 if (__asprintf (&buf,
     861                 :            :                                 _("%s: option requires an argument -- '%c'\n"),
     862                 :            :                                 argv[0], c) >= 0)
     863                 :            :                   {
     864                 :            :                     _IO_flockfile (stderr);
     865                 :            : 
     866                 :            :                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     867                 :            :                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
     868                 :            : 
     869                 :            :                     __fxprintf (NULL, "%s", buf);
     870                 :            : 
     871                 :            :                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     872                 :            :                     _IO_funlockfile (stderr);
     873                 :            : 
     874                 :            :                     free (buf);
     875                 :            :                   }
     876                 :            : #else
     877                 :          0 :                 fprintf (stderr,
     878                 :          0 :                          _("%s: option requires an argument -- '%c'\n"),
     879                 :            :                          argv[0], c);
     880                 :            : #endif
     881                 :            :               }
     882                 :          1 :             d->optopt = c;
     883         [ -  + ]:          1 :             if (optstring[0] == ':')
     884                 :          0 :               c = ':';
     885                 :            :             else
     886                 :          1 :               c = '?';
     887                 :          1 :             return c;
     888                 :            :           }
     889                 :            :         else
     890                 :            :           /* We already incremented 'd->optind' once;
     891                 :            :              increment it again when taking next ARGV-elt as argument.  */
     892                 :         13 :           d->optarg = argv[d->optind++];
     893                 :            : 
     894                 :            :         /* optarg is now the argument, see if it's in the
     895                 :            :            table of longopts.  */
     896                 :            : 
     897 [ +  + ][ +  + ]:        130 :         for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
     898                 :         96 :              nameend++)
     899                 :            :           /* Do nothing.  */ ;
     900                 :            : 
     901                 :            :         /* Test all long options for either exact match
     902                 :            :            or abbreviated matches.  */
     903         [ +  + ]:        160 :         for (p = longopts, option_index = 0; p->name; p++, option_index++)
     904         [ +  + ]:        140 :           if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
     905                 :            :             {
     906         [ +  + ]:         32 :               if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
     907                 :            :                 {
     908                 :            :                   /* Exact match found.  */
     909                 :         14 :                   pfound = p;
     910                 :         14 :                   indfound = option_index;
     911                 :         14 :                   exact = 1;
     912                 :         14 :                   break;
     913                 :            :                 }
     914         [ +  - ]:         18 :               else if (pfound == NULL)
     915                 :            :                 {
     916                 :            :                   /* First nonexact match found.  */
     917                 :         18 :                   pfound = p;
     918                 :         18 :                   indfound = option_index;
     919                 :            :                 }
     920         [ #  # ]:          0 :               else if (long_only
     921         [ #  # ]:          0 :                        || pfound->has_arg != p->has_arg
     922         [ #  # ]:          0 :                        || pfound->flag != p->flag
     923         [ #  # ]:          0 :                        || pfound->val != p->val)
     924                 :            :                 /* Second or later nonexact match found.  */
     925                 :          0 :                 ambig = 1;
     926                 :            :             }
     927 [ -  + ][ #  # ]:         34 :         if (ambig && !exact)
     928                 :            :           {
     929         [ #  # ]:          0 :             if (print_errors)
     930                 :            :               {
     931                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     932                 :            :                 char *buf;
     933                 :            : 
     934                 :            :                 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
     935                 :            :                                 argv[0], d->optarg) >= 0)
     936                 :            :                   {
     937                 :            :                     _IO_flockfile (stderr);
     938                 :            : 
     939                 :            :                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     940                 :            :                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
     941                 :            : 
     942                 :            :                     __fxprintf (NULL, "%s", buf);
     943                 :            : 
     944                 :            :                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     945                 :            :                     _IO_funlockfile (stderr);
     946                 :            : 
     947                 :            :                     free (buf);
     948                 :            :                   }
     949                 :            : #else
     950                 :          0 :                 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
     951                 :            :                          argv[0], d->optarg);
     952                 :            : #endif
     953                 :            :               }
     954                 :          0 :             d->__nextchar += strlen (d->__nextchar);
     955                 :          0 :             d->optind++;
     956                 :          0 :             return '?';
     957                 :            :           }
     958         [ +  + ]:         34 :         if (pfound != NULL)
     959                 :            :           {
     960                 :         32 :             option_index = indfound;
     961         [ +  + ]:         32 :             if (*nameend)
     962                 :            :               {
     963                 :            :                 /* Don't test has_arg with >, because some C compilers don't
     964                 :            :                    allow it to be used on enums.  */
     965         [ +  - ]:         10 :                 if (pfound->has_arg)
     966                 :         10 :                   d->optarg = nameend + 1;
     967                 :            :                 else
     968                 :            :                   {
     969         [ #  # ]:          0 :                     if (print_errors)
     970                 :            :                       {
     971                 :            : #if defined _LIBC && defined USE_IN_LIBIO
     972                 :            :                         char *buf;
     973                 :            : 
     974                 :            :                         if (__asprintf (&buf, _("\
     975                 :            : %s: option '-W %s' doesn't allow an argument\n"),
     976                 :            :                                         argv[0], pfound->name) >= 0)
     977                 :            :                           {
     978                 :            :                             _IO_flockfile (stderr);
     979                 :            : 
     980                 :            :                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
     981                 :            :                             ((_IO_FILE *) stderr)->_flags2
     982                 :            :                               |= _IO_FLAGS2_NOTCANCEL;
     983                 :            : 
     984                 :            :                             __fxprintf (NULL, "%s", buf);
     985                 :            : 
     986                 :            :                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
     987                 :            :                             _IO_funlockfile (stderr);
     988                 :            : 
     989                 :            :                             free (buf);
     990                 :            :                           }
     991                 :            : #else
     992                 :          0 :                         fprintf (stderr, _("\
     993                 :            : %s: option '-W %s' doesn't allow an argument\n"),
     994                 :            :                                  argv[0], pfound->name);
     995                 :            : #endif
     996                 :            :                       }
     997                 :            : 
     998                 :          0 :                     d->__nextchar += strlen (d->__nextchar);
     999                 :          0 :                     return '?';
    1000                 :            :                   }
    1001                 :            :               }
    1002         [ +  + ]:         22 :             else if (pfound->has_arg == 1)
    1003                 :            :               {
    1004         [ +  - ]:          4 :                 if (d->optind < argc)
    1005                 :          4 :                   d->optarg = argv[d->optind++];
    1006                 :            :                 else
    1007                 :            :                   {
    1008         [ #  # ]:          0 :                     if (print_errors)
    1009                 :            :                       {
    1010                 :            : #if defined _LIBC && defined USE_IN_LIBIO
    1011                 :            :                         char *buf;
    1012                 :            : 
    1013                 :            :                         if (__asprintf (&buf, _("\
    1014                 :            : %s: option '-W %s' requires an argument\n"),
    1015                 :            :                                         argv[0], pfound->name) >= 0)
    1016                 :            :                           {
    1017                 :            :                             _IO_flockfile (stderr);
    1018                 :            : 
    1019                 :            :                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
    1020                 :            :                             ((_IO_FILE *) stderr)->_flags2
    1021                 :            :                               |= _IO_FLAGS2_NOTCANCEL;
    1022                 :            : 
    1023                 :            :                             __fxprintf (NULL, "%s", buf);
    1024                 :            : 
    1025                 :            :                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
    1026                 :            :                             _IO_funlockfile (stderr);
    1027                 :            : 
    1028                 :            :                             free (buf);
    1029                 :            :                           }
    1030                 :            : #else
    1031                 :          0 :                         fprintf (stderr, _("\
    1032                 :            : %s: option '-W %s' requires an argument\n"),
    1033                 :            :                                  argv[0], pfound->name);
    1034                 :            : #endif
    1035                 :            :                       }
    1036                 :          0 :                     d->__nextchar += strlen (d->__nextchar);
    1037         [ #  # ]:          0 :                     return optstring[0] == ':' ? ':' : '?';
    1038                 :            :                   }
    1039                 :            :               }
    1040                 :            :             else
    1041                 :         18 :               d->optarg = NULL;
    1042                 :         32 :             d->__nextchar += strlen (d->__nextchar);
    1043         [ +  - ]:         32 :             if (longind != NULL)
    1044                 :         32 :               *longind = option_index;
    1045         [ +  + ]:         32 :             if (pfound->flag)
    1046                 :            :               {
    1047                 :          8 :                 *(pfound->flag) = pfound->val;
    1048                 :          8 :                 return 0;
    1049                 :            :               }
    1050                 :         24 :             return pfound->val;
    1051                 :            :           }
    1052                 :            : 
    1053                 :            :       no_longs:
    1054                 :          7 :         d->__nextchar = NULL;
    1055                 :          7 :         return 'W';   /* Let the application handle it.   */
    1056                 :            :       }
    1057         [ +  + ]:        265 :     if (temp[1] == ':')
    1058                 :            :       {
    1059         [ +  + ]:        117 :         if (temp[2] == ':')
    1060                 :            :           {
    1061                 :            :             /* This is an option that accepts an argument optionally.  */
    1062         [ +  + ]:         21 :             if (*d->__nextchar != '\0')
    1063                 :            :               {
    1064                 :          7 :                 d->optarg = d->__nextchar;
    1065                 :          7 :                 d->optind++;
    1066                 :            :               }
    1067                 :            :             else
    1068                 :         14 :               d->optarg = NULL;
    1069                 :         21 :             d->__nextchar = NULL;
    1070                 :            :           }
    1071                 :            :         else
    1072                 :            :           {
    1073                 :            :             /* This is an option that requires an argument.  */
    1074         [ +  + ]:         96 :             if (*d->__nextchar != '\0')
    1075                 :            :               {
    1076                 :         12 :                 d->optarg = d->__nextchar;
    1077                 :            :                 /* If we end this ARGV-element by taking the rest as an arg,
    1078                 :            :                    we must advance to the next element now.  */
    1079                 :         12 :                 d->optind++;
    1080                 :            :               }
    1081         [ +  + ]:         84 :             else if (d->optind == argc)
    1082                 :            :               {
    1083         [ +  + ]:         20 :                 if (print_errors)
    1084                 :            :                   {
    1085                 :            : #if defined _LIBC && defined USE_IN_LIBIO
    1086                 :            :                     char *buf;
    1087                 :            : 
    1088                 :            :                     if (__asprintf (&buf, _("\
    1089                 :            : %s: option requires an argument -- '%c'\n"),
    1090                 :            :                                     argv[0], c) >= 0)
    1091                 :            :                       {
    1092                 :            :                         _IO_flockfile (stderr);
    1093                 :            : 
    1094                 :            :                         int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
    1095                 :            :                         ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
    1096                 :            : 
    1097                 :            :                         __fxprintf (NULL, "%s", buf);
    1098                 :            : 
    1099                 :            :                         ((_IO_FILE *) stderr)->_flags2 = old_flags2;
    1100                 :            :                         _IO_funlockfile (stderr);
    1101                 :            : 
    1102                 :            :                         free (buf);
    1103                 :            :                       }
    1104                 :            : #else
    1105                 :          4 :                     fprintf (stderr,
    1106                 :          4 :                              _("%s: option requires an argument -- '%c'\n"),
    1107                 :            :                              argv[0], c);
    1108                 :            : #endif
    1109                 :            :                   }
    1110                 :         20 :                 d->optopt = c;
    1111         [ +  + ]:         20 :                 if (optstring[0] == ':')
    1112                 :         12 :                   c = ':';
    1113                 :            :                 else
    1114                 :          8 :                   c = '?';
    1115                 :            :               }
    1116                 :            :             else
    1117                 :            :               /* We already incremented 'optind' once;
    1118                 :            :                  increment it again when taking next ARGV-elt as argument.  */
    1119                 :         64 :               d->optarg = argv[d->optind++];
    1120                 :         96 :             d->__nextchar = NULL;
    1121                 :            :           }
    1122                 :            :       }
    1123                 :        641 :     return c;
    1124                 :            :   }
    1125                 :            : }
    1126                 :            : 
    1127                 :            : int
    1128                 :        641 : _getopt_internal (int argc, char **argv, const char *optstring,
    1129                 :            :                   const struct option *longopts, int *longind, int long_only,
    1130                 :            :                   int posixly_correct)
    1131                 :            : {
    1132                 :            :   int result;
    1133                 :            : 
    1134                 :        641 :   getopt_data.optind = optind;
    1135                 :        641 :   getopt_data.opterr = opterr;
    1136                 :            : 
    1137                 :        641 :   result = _getopt_internal_r (argc, argv, optstring, longopts,
    1138                 :            :                                longind, long_only, &getopt_data,
    1139                 :            :                                posixly_correct);
    1140                 :            : 
    1141                 :        641 :   optind = getopt_data.optind;
    1142                 :        641 :   optarg = getopt_data.optarg;
    1143                 :        641 :   optopt = getopt_data.optopt;
    1144                 :            : 
    1145                 :        641 :   return result;
    1146                 :            : }
    1147                 :            : 
    1148                 :            : /* glibc gets a LSB-compliant getopt.
    1149                 :            :    Standalone applications get a POSIX-compliant getopt.  */
    1150                 :            : #if _LIBC
    1151                 :            : enum { POSIXLY_CORRECT = 0 };
    1152                 :            : #else
    1153                 :            : enum { POSIXLY_CORRECT = 1 };
    1154                 :            : #endif
    1155                 :            : 
    1156                 :            : int
    1157                 :            : getopt (int argc, char *const *argv, const char *optstring)
    1158                 :            : {
    1159                 :        348 :   return _getopt_internal (argc, (char **) argv, optstring,
    1160                 :            :                            (const struct option *) 0,
    1161                 :            :                            (int *) 0,
    1162                 :            :                            0, POSIXLY_CORRECT);
    1163                 :            : }
    1164                 :            : 
    1165                 :            : #ifdef _LIBC
    1166                 :            : int
    1167                 :            : __posix_getopt (int argc, char *const *argv, const char *optstring)
    1168                 :            : {
    1169                 :            :   return _getopt_internal (argc, argv, optstring,
    1170                 :            :                            (const struct option *) 0,
    1171                 :            :                            (int *) 0,
    1172                 :            :                            0, 1);
    1173                 :            : }
    1174                 :            : #endif
    1175                 :            : 
    1176                 :            : 
    1177                 :            : #ifdef TEST
    1178                 :            : 
    1179                 :            : /* Compile with -DTEST to make an executable for use in testing
    1180                 :            :    the above definition of 'getopt'.  */
    1181                 :            : 
    1182                 :            : int
    1183                 :            : main (int argc, char **argv)
    1184                 :            : {
    1185                 :            :   int c;
    1186                 :            :   int digit_optind = 0;
    1187                 :            : 
    1188                 :            :   while (1)
    1189                 :            :     {
    1190                 :            :       int this_option_optind = optind ? optind : 1;
    1191                 :            : 
    1192                 :            :       c = getopt (argc, argv, "abc:d:0123456789");
    1193                 :            :       if (c == -1)
    1194                 :            :         break;
    1195                 :            : 
    1196                 :            :       switch (c)
    1197                 :            :         {
    1198                 :            :         case '0':
    1199                 :            :         case '1':
    1200                 :            :         case '2':
    1201                 :            :         case '3':
    1202                 :            :         case '4':
    1203                 :            :         case '5':
    1204                 :            :         case '6':
    1205                 :            :         case '7':
    1206                 :            :         case '8':
    1207                 :            :         case '9':
    1208                 :            :           if (digit_optind != 0 && digit_optind != this_option_optind)
    1209                 :            :             printf ("digits occur in two different argv-elements.\n");
    1210                 :            :           digit_optind = this_option_optind;
    1211                 :            :           printf ("option %c\n", c);
    1212                 :            :           break;
    1213                 :            : 
    1214                 :            :         case 'a':
    1215                 :            :           printf ("option a\n");
    1216                 :            :           break;
    1217                 :            : 
    1218                 :            :         case 'b':
    1219                 :            :           printf ("option b\n");
    1220                 :            :           break;
    1221                 :            : 
    1222                 :            :         case 'c':
    1223                 :            :           printf ("option c with value '%s'\n", optarg);
    1224                 :            :           break;
    1225                 :            : 
    1226                 :            :         case '?':
    1227                 :            :           break;
    1228                 :            : 
    1229                 :            :         default:
    1230                 :            :           printf ("?? getopt returned character code 0%o ??\n", c);
    1231                 :            :         }
    1232                 :            :     }
    1233                 :            : 
    1234                 :            :   if (optind < argc)
    1235                 :            :     {
    1236                 :            :       printf ("non-option ARGV-elements: ");
    1237                 :            :       while (optind < argc)
    1238                 :            :         printf ("%s ", argv[optind++]);
    1239                 :            :       printf ("\n");
    1240                 :            :     }
    1241                 :            : 
    1242                 :            :   exit (0);
    1243                 :            : }
    1244                 :            : 
    1245                 :            : #endif /* TEST */

Generated by: LCOV version 1.9