Use setup_work_tree() in builtin-ls-files.c

diff --git a/parse-options.c b/parse-options.c
index c751ebf601825c6354c6e2c7ed650f1693947a45..cc09c98ec3fe19d6f9f5f7a58a3c5956bd7c0578 100644 (file)
--- a/parse-options.c
+++ b/parse-options.c
@@ -72,6 +72,11 @@ static int get_value(struct optparse_t *p,
        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)
@@ -113,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;
+       int abbrev_flags = 0;
+
+       if (!arg_end)
+               arg_end = arg + strlen(arg);
+
        for (; options->type != OPTION_END; options++) {
                const char *rest;
                int flags = 0;
@@ -122,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)
+                                       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 (!(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;
                }
@@ -136,6 +176,8 @@ static int parse_long_opt(struct optparse_t *p, const char *arg,
                }
                return get_value(p, options, flags);
        }
+       if (abbrev_option)
+               return get_value(p, abbrev_option, abbrev_flags);
        return error("unknown option `%s'", arg);
 }
 
@@ -224,8 +266,11 @@ void usage_with_options(const char * const *usagestr,
                        else
                                pos += fprintf(stderr, " <n>");
                        break;
-               case OPTION_STRING:
                case OPTION_CALLBACK:
+                       if (opts->flags & PARSE_OPT_NOARG)
+                               break;
+                       /* FALLTHROUGH */
+               case OPTION_STRING:
                        if (opts->argh) {
                                if (opts->flags & PARSE_OPT_OPTARG)
                                        pos += fprintf(stderr, " [<%s>]", opts->argh);
@@ -254,3 +299,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;
+}