Merge branch 'maint'

[git.git] / parse-options.c

diff --git a/parse-options.c b/parse-options.c
index cc09c98ec3fe19d6f9f5f7a58a3c5956bd7c0578..d3e608ac45e2a0c6accb9d27ed8d407619cb70d2 100644 (file)
--- a/parse-options.c
+++ b/parse-options.c
@@ -40,24 +40,53 @@ static int get_value(struct optparse_t *p,
                      const struct option *opt, int flags)
 {
        const char *s, *arg;
-       arg = p->opt ? p->opt : (p->argc > 1 ? p->argv[1] : NULL);
+       const int unset = flags & OPT_UNSET;
 
-       if (p->opt && (flags & OPT_UNSET))
+       if (unset && p->opt)
                return opterror(opt, "takes no value", flags);
+       if (unset && (opt->flags & PARSE_OPT_NONEG))
+               return opterror(opt, "isn't available", flags);
 
-       switch (opt->type) {
-       case OPTION_BOOLEAN:
-               if (!(flags & OPT_SHORT) && p->opt)
+       if (!(flags & OPT_SHORT) && p->opt) {
+               switch (opt->type) {
+               case OPTION_CALLBACK:
+                       if (!(opt->flags & PARSE_OPT_NOARG))
+                               break;
+                       /* FALLTHROUGH */
+               case OPTION_BOOLEAN:
+               case OPTION_BIT:
+               case OPTION_SET_INT:
+               case OPTION_SET_PTR:
                        return opterror(opt, "takes no value", flags);
-               if (flags & OPT_UNSET)
-                       *(int *)opt->value = 0;
+               default:
+                       break;
+               }
+       }
+
+       arg = p->opt ? p->opt : (p->argc > 1 ? p->argv[1] : NULL);
+       switch (opt->type) {
+       case OPTION_BIT:
+               if (unset)
+                       *(int *)opt->value &= ~opt->defval;
                else
-                       (*(int *)opt->value)++;
+                       *(int *)opt->value |= opt->defval;
+               return 0;
+
+       case OPTION_BOOLEAN:
+               *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
+               return 0;
+
+       case OPTION_SET_INT:
+               *(int *)opt->value = unset ? 0 : opt->defval;
+               return 0;
+
+       case OPTION_SET_PTR:
+               *(void **)opt->value = unset ? NULL : (void *)opt->defval;
                return 0;
 
        case OPTION_STRING:
-               if (flags & OPT_UNSET) {
-                       *(const char **)opt->value = (const char *)NULL;
+               if (unset) {
+                       *(const char **)opt->value = NULL;
                        return 0;
                }
                if (opt->flags & PARSE_OPT_OPTARG && (!arg || *arg == '-')) {
@@ -70,13 +99,10 @@ static int get_value(struct optparse_t *p,
                return 0;
 
        case OPTION_CALLBACK:
-               if (flags & OPT_UNSET)
+               if (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);
+               if (opt->flags & PARSE_OPT_NOARG)
                        return (*opt->callback)(opt, NULL, 0);
-               }
                if (opt->flags & PARSE_OPT_OPTARG && (!arg || *arg == '-'))
                        return (*opt->callback)(opt, NULL, 0);
                if (!arg)
@@ -84,7 +110,7 @@ static int get_value(struct optparse_t *p,
                return (*opt->callback)(opt, get_arg(p), 0);
 
        case OPTION_INTEGER:
-               if (flags & OPT_UNSET) {
+               if (unset) {
                        *(int *)opt->value = 0;
                        return 0;
                }
@@ -119,8 +145,8 @@ 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;
-       int abbrev_flags = 0;
+       const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
+       int abbrev_flags = 0, ambiguous_flags = 0;
 
        if (!arg_end)
                arg_end = arg + strlen(arg);
@@ -137,16 +163,16 @@ static int parse_long_opt(struct optparse_t *p, const char *arg,
                        /* abbreviated? */
                        if (!strncmp(options->long_name, arg, arg_end - arg)) {
 is_abbreviated:
-                               if (abbrev_option)
-                                       return error("Ambiguous option: %s "
-                                               "(could be --%s%s or --%s%s)",
-                                               arg,
-                                               (flags & OPT_UNSET) ?
-                                                       "no-" : "",
-                                               options->long_name,
-                                               (abbrev_flags & OPT_UNSET) ?
-                                                       "no-" : "",
-                                               abbrev_option->long_name);
+                               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;
@@ -176,6 +202,15 @@ is_abbreviated:
                }
                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);
@@ -283,7 +318,7 @@ void usage_with_options(const char * const *usagestr,
                                        pos += fprintf(stderr, " ...");
                        }
                        break;
-               default:
+               default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
                        break;
                }
 
@@ -302,6 +337,7 @@ void usage_with_options(const char * const *usagestr,
 
 /*----- some often used options -----*/
 #include "cache.h"
+
 int parse_opt_abbrev_cb(const struct option *opt, const char *arg, int unset)
 {
        int v;