[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
patch to clean up lib/glob.c which may only help readability
|
From: |
Dennis Clarke |
|
Subject: |
patch to clean up lib/glob.c which may only help readability |
|
Date: |
Tue, 27 Aug 2019 16:58:13 -0400 |
|
User-agent: |
Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Thunderbird/69.0 |
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
- patch to clean up lib/glob.c which may only help readability,
Dennis Clarke <=