rehabilitate some t5302 tests on 32-bit off_t machines

diff --git a/parse-options.c b/parse-options.c
index 89c5f52be567cc5ee59e4d89e0ef671dd6d502ba..15b32f741b6b8bf47321b9ce78da43e9378f22b3 100644 (file)
--- a/parse-options.c
+++ b/parse-options.c
@@ -39,7 +39,8 @@ static int opterror(const struct option *opt, const char *reason, int flags)
 static int get_value(struct optparse_t *p,
                      const struct option *opt, int flags)
 {
-       const char *s;
+       const char *s, *arg;
+       arg = p->opt ? p->opt : (p->argc > 1 ? p->argv[1] : NULL);
 
        if (p->opt && (flags & OPT_UNSET))
                return opterror(opt, "takes no value", flags);
@@ -59,17 +60,39 @@ static int get_value(struct optparse_t *p,
                        *(const char **)opt->value = (const char *)NULL;
                        return 0;
                }
-               if (!p->opt && p->argc <= 1)
+               if (opt->flags & PARSE_OPT_OPTARG && (!arg || *arg == '-')) {
+                       *(const char **)opt->value = (const char *)opt->defval;
+                       return 0;
+               }
+               if (!arg)
                        return opterror(opt, "requires a value", flags);
                *(const char **)opt->value = get_arg(p);
                return 0;
 
+       case OPTION_CALLBACK:
+               if (flags & OPT_UNSET)
+                       return (*opt->callback)(opt, NULL, 1);
+               if (opt->flags & PARSE_OPT_NOARG) {
+                       if (p->opt && !(flags & OPT_SHORT))
+                               return opterror(opt, "takes no value", flags);
+                       return (*opt->callback)(opt, NULL, 0);
+               }
+               if (opt->flags & PARSE_OPT_OPTARG && (!arg || *arg == '-'))
+                       return (*opt->callback)(opt, NULL, 0);
+               if (!arg)
+                       return opterror(opt, "requires a value", flags);
+               return (*opt->callback)(opt, get_arg(p), 0);
+
        case OPTION_INTEGER:
                if (flags & OPT_UNSET) {
                        *(int *)opt->value = 0;
                        return 0;
                }
-               if (!p->opt && p->argc <= 1)
+               if (opt->flags & PARSE_OPT_OPTARG && (!arg || !isdigit(*arg))) {
+                       *(int *)opt->value = opt->defval;
+                       return 0;
+               }
+               if (!arg)
                        return opterror(opt, "requires a value", flags);
                *(int *)opt->value = strtol(get_arg(p), (char **)&s, 10);
                if (*s)
@@ -95,6 +118,13 @@ static int parse_short_opt(struct optparse_t *p, const struct option *options)
 static int parse_long_opt(struct optparse_t *p, const char *arg,
                           const struct option *options)
 {
+       const char *arg_end = strchr(arg, '=');
+       const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
+       int abbrev_flags = 0, ambiguous_flags = 0;
+
+       if (!arg_end)
+               arg_end = arg + strlen(arg);
+
        for (; options->type != OPTION_END; options++) {
                const char *rest;
                int flags = 0;
@@ -104,10 +134,38 @@ static int parse_long_opt(struct optparse_t *p, const char *arg,
 
                rest = skip_prefix(arg, options->long_name);
                if (!rest) {
+                       /* abbreviated? */
+                       if (!strncmp(options->long_name, arg, arg_end - arg)) {
+is_abbreviated:
+                               if (abbrev_option) {
+                                       /*
+                                        * If this is abbreviated, it is
+                                        * ambiguous. So when there is no
+                                        * exact match later, we need to
+                                        * error out.
+                                        */
+                                       ambiguous_option = abbrev_option;
+                                       ambiguous_flags = abbrev_flags;
+                               }
+                               if (!(flags & OPT_UNSET) && *arg_end)
+                                       p->opt = arg_end + 1;
+                               abbrev_option = options;
+                               abbrev_flags = flags;
+                               continue;
+                       }
+                       /* negated and abbreviated very much? */
+                       if (!prefixcmp("no-", arg)) {
+                               flags |= OPT_UNSET;
+                               goto is_abbreviated;
+                       }
+                       /* negated? */
                        if (strncmp(arg, "no-", 3))
                                continue;
                        flags |= OPT_UNSET;
                        rest = skip_prefix(arg + 3, options->long_name);
+                       /* abbreviated and negated? */
+                       if (!rest && !prefixcmp(options->long_name, arg + 3))
+                               goto is_abbreviated;
                        if (!rest)
                                continue;
                }
@@ -118,6 +176,17 @@ static int parse_long_opt(struct optparse_t *p, const char *arg,
                }
                return get_value(p, options, flags);
        }
+
+       if (ambiguous_option)
+               return error("Ambiguous option: %s "
+                       "(could be --%s%s or --%s%s)",
+                       arg,
+                       (ambiguous_flags & OPT_UNSET) ?  "no-" : "",
+                       ambiguous_option->long_name,
+                       (abbrev_flags & OPT_UNSET) ?  "no-" : "",
+                       abbrev_option->long_name);
+       if (abbrev_option)
+               return get_value(p, abbrev_option, abbrev_flags);
        return error("unknown option `%s'", arg);
 }
 
@@ -201,13 +270,27 @@ void usage_with_options(const char * const *usagestr,
 
                switch (opts->type) {
                case OPTION_INTEGER:
-                       pos += fprintf(stderr, " <n>");
+                       if (opts->flags & PARSE_OPT_OPTARG)
+                               pos += fprintf(stderr, " [<n>]");
+                       else
+                               pos += fprintf(stderr, " <n>");
                        break;
+               case OPTION_CALLBACK:
+                       if (opts->flags & PARSE_OPT_NOARG)
+                               break;
+                       /* FALLTHROUGH */
                case OPTION_STRING:
-                       if (opts->argh)
-                               pos += fprintf(stderr, " <%s>", opts->argh);
-                       else
-                               pos += fprintf(stderr, " ...");
+                       if (opts->argh) {
+                               if (opts->flags & PARSE_OPT_OPTARG)
+                                       pos += fprintf(stderr, " [<%s>]", opts->argh);
+                               else
+                                       pos += fprintf(stderr, " <%s>", opts->argh);
+                       } else {
+                               if (opts->flags & PARSE_OPT_OPTARG)
+                                       pos += fprintf(stderr, " [...]");
+                               else
+                                       pos += fprintf(stderr, " ...");
+                       }
                        break;
                default:
                        break;
@@ -225,3 +308,24 @@ void usage_with_options(const char * const *usagestr,
 
        exit(129);
 }
+
+/*----- some often used options -----*/
+#include "cache.h"
+int parse_opt_abbrev_cb(const struct option *opt, const char *arg, int unset)
+{
+       int v;
+
+       if (!arg) {
+               v = unset ? 0 : DEFAULT_ABBREV;
+       } else {
+               v = strtol(arg, (char **)&arg, 10);
+               if (*arg)
+                       return opterror(opt, "expects a numerical value", 0);
+               if (v && v < MINIMUM_ABBREV)
+                       v = MINIMUM_ABBREV;
+               else if (v > 40)
+                       v = 40;
+       }
+       *(int *)(opt->value) = v;
+       return 0;
+}