patch to clean up lib/glob.c which may only help readability

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

patch to clean up lib/glob.c which may only help readability

Dennis Clarke

I tried reading through lib/glob.c as it lays there today and it was a
bit messy.  So I ran a chunk through the cb ( C Code Beautifier ) on ye
Solaris 10 system with Oracle Studio 12.6 and then went line by line to
make it more obvious. I tried to keep lines to 71 chars long.


*** ./lib/glob.c.orig   Sun Aug 25 16:57:50 2019
--- ./lib/glob.c        Mon Aug 26 19:54:23 2019
***************
*** 820,831 ****
               && S_ISDIR (st.st_mode)))
         {
           pglob->gl_pathv
!           = (char **) realloc (pglob->gl_pathv,
!                                (pglob->gl_pathc +
!                                 ((flags & GLOB_DOOFFS) ?
!                                  pglob->gl_offs : 0) +
!                                 1 + 1) *
!                                sizeof (char *));
           if (pglob->gl_pathv == NULL)
             return GLOB_NOSPACE;

--- 820,831 ----
               && S_ISDIR (st.st_mode)))
         {
           pglob->gl_pathv
!         = (char **) realloc ((char *)(pglob->gl_pathv),
!                      (pglob->gl_pathc +
!                       ((flags & GLOB_DOOFFS) ?
!                        pglob->gl_offs : 0) +
!                         1 + 1) * sizeof (char *));
!
           if (pglob->gl_pathv == NULL)
             return GLOB_NOSPACE;

***************
*** 926,932 ****

         /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir'
calls.
          But if we have not found any matching entry and thie GLOB_NOCHECK
!        flag was set we must return the list consisting of the disrectory
          names followed by the filename.  */
         if (pglob->gl_pathc == oldcount)
         {
--- 926,932 ----

         /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir'
calls.
          But if we have not found any matching entry and thie GLOB_NOCHECK
!        flag was set we must return the list consisting of the directory
          names followed by the filename.  */
         if (pglob->gl_pathc == oldcount)
         {
***************
*** 937,945 ****
               char **new_pathv;
               struct stat st;

!             /* This is an pessimistic guess about the size.  */
               pglob->gl_pathv
!               = (char **) realloc (pglob->gl_pathv,
                                      (pglob->gl_pathc +
                                       ((flags & GLOB_DOOFFS) ?
                                        pglob->gl_offs : 0) +
--- 937,945 ----
               char **new_pathv;
               struct stat st;

!             /* This is a pessimistic guess about the size.  */
               pglob->gl_pathv
!               = (char **) realloc ((char *)(pglob->gl_pathv),
                                      (pglob->gl_pathc +
                                       ((flags & GLOB_DOOFFS) ?
                                        pglob->gl_offs : 0) +
***************
*** 994,1000 ****
               pglob->gl_flags = flags;

               /* Now we know how large the gl_pathv vector must be.  */
!             new_pathv = (char **) realloc (pglob->gl_pathv,
                                              ((pglob->gl_pathc + 1)
                                               * sizeof (char *)));
               if (new_pathv != NULL)
--- 994,1000 ----
               pglob->gl_flags = flags;

               /* Now we know how large the gl_pathv vector must be.  */
!             new_pathv = (char **) realloc ((char *)(pglob->gl_pathv),
                                              ((pglob->gl_pathc + 1)
                                               * sizeof (char *)));
               if (new_pathv != NULL)
***************
*** 1385,1391 ****
     if (nfound != 0)
       {
         pglob->gl_pathv
!       = (char **) realloc (pglob->gl_pathv,
                              (pglob->gl_pathc +
                               ((flags & GLOB_DOOFFS) ? pglob->gl_offs :
0) +
                               nfound + 1) *
--- 1385,1391 ----
     if (nfound != 0)
       {
         pglob->gl_pathv
!       = (char **) realloc ((char *)(pglob->gl_pathv),
                              (pglob->gl_pathc +
                               ((flags & GLOB_DOOFFS) ? pglob->gl_offs :
0) +
                               nfound + 1) *
*** ./src/getopt.c.orig Sun Aug 25 16:57:50 2019
--- ./src/getopt.c      Mon Aug 26 21:27:17 2019
***************
*** 497,947 ****

   int
   _getopt_internal (int argc, char *const *argv, const char *optstring,
!                   const struct option *longopts, int *longind, int
long_only)
   {
!   optarg = NULL;

!   if (optind == 0 || !__getopt_initialized)
!     {
!       if (optind == 0)
!       optind = 1;     /* Don't scan ARGV[0], the program name.  */
!       optstring = _getopt_initialize (argc, argv, optstring);
!       __getopt_initialized = 1;
       }

!   /* Test whether ARGV[optind] points to a non-option argument.
!      Either it does not have option syntax, or there is an environment
flag
!      from the shell indicating it is not an option.  The later information
!      is only used when the used in the GNU libc.  */
   #ifdef _LIBC
! # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] ==
'\0'             \
!                     || (optind < nonoption_flags_len
      \
!                         && __getopt_nonoption_flags[optind] == '1'))
   #else
   # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
   #endif

!   if (nextchar == NULL || *nextchar == '\0')
!     {
!       /* Advance to the next ARGV-element.  */

!       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has
been
!        moved back by the user (who may also have changed the
arguments).  */
!       if (last_nonopt > optind)
!       last_nonopt = optind;
!       if (first_nonopt > optind)
!       first_nonopt = optind;

!       if (ordering == PERMUTE)
!       {
!         /* If we have just processed some options following some
non-options,
!            exchange them so that the options come first.  */

!         if (first_nonopt != last_nonopt && last_nonopt != optind)
!           exchange ((char **) argv);
!         else if (last_nonopt != optind)
!           first_nonopt = optind;

!         /* Skip any additional non-options
!            and extend the range of non-options previously skipped.  */

!         while (optind < argc && NONOPTION_P)
!           optind++;
!         last_nonopt = 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 (optind != argc && !strcmp (argv[optind], "--"))
!       {
!         optind++;

!         if (first_nonopt != last_nonopt && last_nonopt != optind)
!           exchange ((char **) argv);
!         else if (first_nonopt == last_nonopt)
!           first_nonopt = optind;
!         last_nonopt = argc;

!         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 (optind == argc)
!       {
!         /* Set the next-arg-index to point at the non-options
!            that we previously skipped, so the caller will digest them.  */
!         if (first_nonopt != last_nonopt)
!           optind = 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 (ordering == REQUIRE_ORDER)
!           return -1;
!         optarg = argv[optind++];
!         return 1;
!       }

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

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

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

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

!      If long_only and the ARGV-element has the form "-f", where f is
!      a valid short option, don't consider it an abbreviated form of
!      a long option that starts with f.  Otherwise there would be no
!      way to give the -f short option.

!      On the other hand, if there's a long option "fubar" and
!      the ARGV-element is "-fu", do consider that an abbreviation of
!      the long option, just like "--fu", and not "-f" with arg "u".

!      This distinction seems to be the most useful approach.  */

!   if (longopts != NULL
!       && (argv[optind][1] == '-'
!         || (long_only && (argv[optind][2] || !my_index (optstring,
argv[optind][1])))))
!     {
!       char *nameend;
!       const struct option *p;
!       const struct option *pfound = NULL;
!       int exact = 0;
!       int ambig = 0;
!       int indfound = -1;
!       int option_index;

!       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
!       /* Do nothing.  */ ;

!       /* Test all long options for either exact match
!        or abbreviated matches.  */
!       for (p = longopts, option_index = 0; p->name; p++, option_index++)
!       if (!strncmp (p->name, nextchar, nameend - nextchar))
!         {
!           if ((unsigned int) (nameend - nextchar)
!               == (unsigned int) strlen (p->name))
!             {
!               /* Exact match found.  */
!               pfound = p;
!               indfound = option_index;
!               exact = 1;
!               break;
!             }
!           else if (pfound == NULL)
!             {
!               /* First nonexact match found.  */
!               pfound = p;
!               indfound = option_index;
!             }
!           else
!             /* Second or later nonexact match found.  */
!             ambig = 1;
!         }

!       if (ambig && !exact)
!       {
!         if (opterr)
!           fprintf (stderr, _("%s: option '%s' is ambiguous\n"),
!                    argv[0], argv[optind]);
!         nextchar += strlen (nextchar);
!         optind++;
!         optopt = 0;
!         return '?';
!       }

!       if (pfound != NULL)
!       {
!         option_index = indfound;
!         optind++;
!         if (*nameend)
!           {
!             /* Don't test has_arg with >, because some C compilers don't
!                allow it to be used on enums.  */
!             if (pfound->has_arg)
!               optarg = nameend + 1;
!             else
!               {
!                 if (opterr)
!                  if (argv[optind - 1][1] == '-')
!                   /* --option */
!                   fprintf (stderr,
!                    _("%s: option '--%s' doesn't allow an argument\n"),
!                    argv[0], pfound->name);
!                  else
!                   /* +option or -option */
!                   fprintf (stderr,
!                    _("%s: option '%c%s' doesn't allow an argument\n"),
!                    argv[0], argv[optind - 1][0], pfound->name);

!                 nextchar += strlen (nextchar);

!                 optopt = pfound->val;
!                 return '?';
!               }
!           }
!         else if (pfound->has_arg == 1)
!           {
!             if (optind < argc)
!               optarg = argv[optind++];
!             else
!               {
!                 if (opterr)
!                   fprintf (stderr,
!                          _("%s: option '%s' requires an argument\n"),
!                          argv[0], argv[optind - 1]);
!                 nextchar += strlen (nextchar);
!                 optopt = pfound->val;
!                 return optstring[0] == ':' ? ':' : '?';
!               }
!           }
!         nextchar += strlen (nextchar);
!         if (longind != NULL)
!           *longind = option_index;
!         if (pfound->flag)
!           {
!             *(pfound->flag) = pfound->val;
!             return 0;
!           }
!         return pfound->val;
!       }

!       /* Can't find it as a long option.  If this is not getopt_long_only,
!        or the option starts with '--' or is not a valid short
!        option, then it's an error.
!        Otherwise interpret it as a short option.  */
!       if (!long_only || argv[optind][1] == '-'
!         || my_index (optstring, *nextchar) == NULL)
!       {
!         if (opterr)
!           {
!             if (argv[optind][1] == '-')
!               /* --option */
!               fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
!                        argv[0], nextchar);
!             else
!               /* +option or -option */
!               fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
!                        argv[0], argv[optind][0], nextchar);
!           }
!         nextchar = (char *) "";
!         optind++;
!         optopt = 0;
!         return '?';
!       }
       }

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

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

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

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

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

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

!       for (nextchar = nameend = optarg; *nameend && *nameend != '=';
nameend++)
!         /* Do nothing.  */ ;

!       /* Test all long options for either exact match
!          or abbreviated matches.  */
!       for (p = longopts, option_index = 0; p->name; p++, option_index++)
!         if (!strncmp (p->name, nextchar, nameend - nextchar))
!           {
!             if ((unsigned int) (nameend - nextchar) == strlen (p->name))
!               {
!                 /* Exact match found.  */
!                 pfound = p;
!                 indfound = option_index;
!                 exact = 1;
!                 break;
!               }
!             else if (pfound == NULL)
!               {
!                 /* First nonexact match found.  */
!                 pfound = p;
!                 indfound = option_index;
!               }
!             else
!               /* Second or later nonexact match found.  */
!               ambig = 1;
!           }
!       if (ambig && !exact)
!         {
!           if (opterr)
!             fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
!                      argv[0], argv[optind]);
!           nextchar += strlen (nextchar);
!           optind++;
!           return '?';
!         }
!       if (pfound != NULL)
!         {
!           option_index = indfound;
!           if (*nameend)
!             {
!               /* Don't test has_arg with >, because some C compilers don't
!                  allow it to be used on enums.  */
!               if (pfound->has_arg)
!                 optarg = nameend + 1;
!               else
!                 {
!                   if (opterr)
!                     fprintf (stderr, _("\
! %s: option '-W %s' doesn't allow an argument\n"),
!                              argv[0], pfound->name);

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

   int
--- 497,969 ----

   int
   _getopt_internal (int argc, char *const *argv, const char *optstring,
! const struct option *longopts, int *longind, int long_only)
   {
!     optarg = NULL;

!     if (optind == 0 || !__getopt_initialized) {
!         if (optind == 0)
!             optind = 1;    /* Don't scan ARGV[0], the program name.  */
!         optstring = _getopt_initialize (argc, argv, optstring);
!         __getopt_initialized = 1;
       }

!     /* Test whether ARGV[optind] points to a non-option argument.
!      * Either it does not have option syntax, or there is an
!      * environment flag from the shell indicating it is not an option.
!      * The later information is only used when the used in the
!      * GNU libc. */
!
   #ifdef _LIBC
! # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] ==
'\0'          \
!               || (optind < nonoption_flags_len                  \
!               && __getopt_nonoption_flags[optind] == '1'))
   #else
   # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
   #endif

!     if (nextchar == NULL || *nextchar == '\0') {
!         /* Advance to the next ARGV-element.  */

!         /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has
!          * been moved back by the user (who may also have changed the
!          * arguments).*/
!         if (last_nonopt > optind)
!             last_nonopt = optind;

!         if (first_nonopt > optind)
!             first_nonopt = optind;

!         if (ordering == PERMUTE) {
!             /* If we have just processed some options following some
!              * non-options, exchange them so that the options come
!              * first.  */

!             if (first_nonopt != last_nonopt && last_nonopt != optind)
!                 exchange ((char **) argv);
!             else if (last_nonopt != optind)
!                 first_nonopt = optind;

!             /* Skip any additional non-options and extend the range of
!              * non-options previously skipped.  */

!             while (optind < argc && NONOPTION_P)
!                 optind++;

!             last_nonopt = 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 (optind != argc && !strcmp (argv[optind], "--")) {
!             optind++;

!             if (first_nonopt != last_nonopt && last_nonopt != optind)
!                 exchange ((char **) argv);
!             else if (first_nonopt == last_nonopt)
!                 first_nonopt = optind;

!             last_nonopt = argc;

!             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 (optind == argc) {
!             /* Set the next-arg-index to point at the non-options that
!              * we previously skipped, so the caller will digest them. */
!             if (first_nonopt != last_nonopt)
!                 optind = first_nonopt;

!             return - 1;
!         }
!
!         /* If we have come to a non-option and did not permute it
!          * then either stop the scan or describe it to the caller
!          * and pass it by.  */
!
!         if (NONOPTION_P) {
!             if (ordering == REQUIRE_ORDER)
!                 return - 1;
!
!             optarg = argv[optind++];
!             return 1;
!         }
!
!         /* We have found another option-ARGV-element.
!          * Skip the initial punctuation. */
!
!         nextchar = (argv[optind] + 1
!                    + (longopts != NULL && argv[optind][1] == '-'));
!
       }

!     /* Decode the current option-ARGV-element.
!      *
!      * Check whether the ARGV-element is a long option.
!      *
!      *   If long_only and the ARGV-element has the form "-f", where f is
!      *   a valid short option, don't consider it an abbreviated form of
!      *   a long option that starts with f.  Otherwise there would be no
!      *   way to give the -f short option.
!      *
!      *   On the other hand, if there's a long option "fubar" and
!      *   the ARGV-element is "-fu", do consider that an abbreviation of
!      *   the long option, just like "--fu", and not "-f" with arg "u".
!      *
!      *   This distinction seems to be the most useful approach. */

!     if (longopts != NULL
!          && (argv[optind][1] == '-'
!              || (long_only && (argv[optind][2]
!                  || !my_index (optstring, argv[optind][1]))
!                 )
!             )) {

!         char    *nameend;
!         const struct option *p;
!         const struct option *pfound = NULL;
!         int    exact = 0;
!         int    ambig = 0;
!         int    indfound = -1;
!         int    option_index;

!         /* do nothing */
!         for (nameend = nextchar; *nameend && *nameend != '='; nameend++);

!         /* Test all long options for either exact match
!          * or abbreviated matches.  */
!         for (p = longopts, option_index = 0; p->name; p++, option_index++)
!             if (!strncmp (p->name, nextchar, nameend - nextchar)) {
!                 if ((unsigned int) (nameend - nextchar)
!                      == (unsigned int) strlen (p->name)) {
!                     /* Exact match found.  */
!                     pfound = p;
!                     indfound = option_index;
!                     exact = 1;
!                     break;
!                 } else if (pfound == NULL) {
!                     /* First nonexact match found.  */
!                     pfound = p;
!                     indfound = option_index;
!                 } else
!                     /* Second or later nonexact match found.  */
!                     ambig = 1;
!             }

!         if (ambig && !exact) {

!             if (opterr)
!                 fprintf (stderr, _("%s: option '%s' is ambiguous\n"),
!                                  argv[0], argv[optind]);

!             nextchar += strlen (nextchar);
!             optind++;
!             optopt = 0;
!             return '?';
!         }

!         if (pfound != NULL) {
!             option_index = indfound;
!             optind++;
!             if (*nameend) {
!                 /* Do not test has_arg with the > operator because some
!                  * C compilers do not allow it to be used on enums.  */
!                 if (pfound->has_arg) {
!                     optarg = nameend + 1;
!                 } else {
!                     if (opterr) {
!                         fprintf (stderr, _("%s: option"), argv[0]);
!                         if (argv[optind - 1][1] == '-') {
!                             /* --option */
!                             fprintf (stderr,
!                                      _("'--%s' doesn't allow an
argument\n"),
!                                        pfound->name);

!                         } else {
!                             /* +option or -option */
!                             fprintf (stderr,
!                                 _("'%c%s' doesn't allow an argument\n"),
!                                    argv[optind - 1][0], pfound->name);
!                         }
!                     }

!                     nextchar += strlen (nextchar);

!                     optopt = pfound->val;
!                     return '?';
!                 }
!             } else {
!                 if (pfound->has_arg == 1) {
!                     if (optind < argc) {
!                         optarg = argv[optind++];
!                     } else {
!                         if (opterr) {

!                             fprintf (stderr, _("%s: option"), argv[0]);
!
!                             fprintf (stderr, _("'%s' requires an
argument\n"),
!                                              argv[optind - 1]);
!                         }
!
!                         nextchar += strlen (nextchar);
!                         optopt = pfound->val;
!                         return optstring[0] == ':' ? ':' : '?';
!                     }
!                 }
!             }
!
!             nextchar += strlen (nextchar);
!
!             if (longind != NULL)
!                 *longind = option_index;
!
!             if (pfound->flag) {
!                 *(pfound->flag) = pfound->val;
!                 return 0;
!             }
!
!             return pfound->val;
!         }
!
!         /* Can't find it as a long option.  If this is not
!          * getopt_long_only, or the option starts with '--' or is not
!          * a valid short option, then it's an error.
!          * Otherwise interpret it as a short option.  */
!         if (!long_only
!              || argv[optind][1] == '-'
!              || ( my_index (optstring, *nextchar) == NULL )) {
!
!             if (opterr) {
!                 if (argv[optind][1] == '-') {
!                     /* --option */
!                     fprintf (stderr, _("%s: unrecognized option
'--%s'\n"),
!                         argv[0], nextchar);
!                 } else {
!                     /* +option or -option */
!                     fprintf (stderr, _("%s: unrecognized option
'%c%s'\n"),
!                         argv[0], argv[optind][0], nextchar);
!                 }
!             }
!
!             nextchar = (char *) "";
!             optind++;
!             optopt = 0;
!             return '?';
!         }
       }

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

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

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

!         if (temp == NULL || c == ':') {
!             if (opterr) {
!                 fprintf (stderr, _("%s: "), argv[0]);
!                 if (posixly_correct) {
!                     /* 1003.2 specifies the format of this message.  */
!                     fprintf (stderr, _("illegal option -- %c\n"), c);
!                 } else {
!                     fprintf (stderr, _("invalid option -- %c\n"), c);
!                 }
!             }
!             optopt = c;
!             return '?';
!         }

!         /* Convenience. Treat POSIX -W foo same as long option --foo */
!         if (temp[0] == 'W' && temp[1] == ';') {
!             char    *nameend;
!             const struct option *p;
!             const struct option *pfound = NULL;
!             int    exact = 0;
!             int    ambig = 0;
!             int    indfound = 0;
!             int    option_index;

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

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

!             /* do nothing */
!             for (nextchar = nameend = optarg; *nameend && *nameend !=
'='; nameend++);

!             /* Test all long options for either exact match
!              * or abbreviated matches.  */
!             for (p = longopts, option_index = 0; p->name; p++,
option_index++) {
!                 if (!strncmp(p->name, nextchar, nameend - nextchar)) {
!                     if ((unsigned int)(nameend - nextchar) ==
strlen(p->name)) {
!                         /* Exact match */
!                         pfound = p;
!                         indfound = option_index;
!                         exact = 1;
!                         break;
!                     } else if (pfound == NULL) {
!                         /* First nonexact match found.  */
!                         pfound = p;
!                         indfound = option_index;
!                     } else {
!                         /* Second or later nonexact match found.  */
!                         ambig = 1;
!                     }
!                 }
!             }
!
!             if (ambig && !exact) {
!                 if (opterr) {
!                     fprintf (stderr, _("%s: option '-W %s' is
ambiguous\n"),
!                              argv[0], argv[optind]);
!                 }
!                 nextchar += strlen (nextchar);
!                 optind++;
!                 return '?';
!             }
!
!             if (pfound != NULL) {
!                 option_index = indfound;
!                 if (*nameend) {
!                     /* Do not test has_arg with the > operator because
!                      * some C compilers do not allow it to be used on
!                      * enums.  */
!                     if (pfound->has_arg) {
!                         optarg = nameend + 1;
!                     } else {
!                         if (opterr) {
!                             fprintf (stderr, _("%s: option "), argv[0]);
!                             fprintf (stderr, _("'-W %s' "), pfound->name);
!                             fprintf (stderr, _("doesn't allow an
argument\n"));
!                         }
!
!                         nextchar += strlen (nextchar);
!                         return '?';
!
!                     }
!                 } else if (pfound->has_arg == 1) {
!                     if (optind < argc) {
!                         optarg = argv[optind++];
!                     } else {
!                         if (opterr) {
!                             fprintf (stderr, _("%s: option "), argv[0]);
!                             fprintf (stderr, _("'%s' requires an
argument\n"),
!                                                       argv[optind - 1]);
!                         }
!
!                         nextchar += strlen (nextchar);
!                         return optstring[0] == ':' ? ':' : '?';
!                     }
!                 }
!
!                 nextchar += strlen (nextchar);
!
!                 if (longind != NULL)
!                     *longind = option_index;
!
!                 if (pfound->flag) {
!                     *(pfound->flag) = pfound->val;
!                     return 0;
!                 }
!
!                 return pfound->val;
!
!             }
!
!             nextchar = NULL;
!             return 'W';    /* Let the application handle it.   */
!
!         }
!
!         if (temp[1] == ':') {
!             if (temp[2] == ':') {
!
!                 /* This is an option that accepts an argument
optionally.  */
!                 if (*nextchar != '\0') {
!                     optarg = nextchar;
!                     optind++;
!                 } else {
!                     optarg = NULL;
!                 }
!
!                 nextchar = NULL;
!
!             } else {
!                 /* This is an option that requires an argument.  */
!                 if (*nextchar != '\0') {
!
!                     optarg = nextchar;
!                     /* If we end this ARGV-element by taking the rest as
!                      * an arg, we must advance to the next element
now.  */
!                     optind++;
!
!                 } else if (optind == argc) {
!
!                     if (opterr) {
!                         /* 1003.2 specifies the format of this
message.  */
!                         fprintf (stderr,
!                             _("%s: option requires an argument -- %c\n"),
!                             argv[0], c);
!                     }
!
!                     optopt = c;
!
!                     if (optstring[0] == ':') {
!                         c = ':';
!                     } else {
!                         c = '?';
!                     }
!
!                 } else {
!                     /* We already incremented `optind' once  so here we
!                      * increment it again when taking next ARGV-elt
!                      * as argument.  */
!                     optarg = argv[optind++];
!                 }
!
!                 nextchar = NULL;
!
!             }
!
!         }
!
!         return c;
!
!     }
   }

   int


I tested on various systems and made no impact on tests failing or not.
Then again that is the whole struggle.


--
Dennis Clarke
RISC-V/SPARC/PPC/ARM/CISC
UNIX and Linux spoken
GreyBeard and suspenders optional

_______________________________________________
Bug-make mailing list
[hidden email]
https://lists.gnu.org/mailman/listinfo/bug-make
Reply | Threaded
Open this post in threaded view
|

Re: patch to clean up lib/glob.c which may only help readability

Dennis Clarke

Sorry src/getopt.c was the major eye strain that I fixed there.

Dennis


_______________________________________________
Bug-make mailing list
[hidden email]
https://lists.gnu.org/mailman/listinfo/bug-make