Andrew's git - gitweb.git/blob - parse-options-cb.c

   1#include "git-compat-util.h"
   2#include "parse-options.h"
   3#include "cache.h"
   4#include "commit.h"
   5#include "color.h"
   6#include "string-list.h"
   7#include "argv-array.h"
   8#include "sha1-array.h"
   9
  10/*----- some often used options -----*/
  11
  12int parse_opt_abbrev_cb(const struct option *opt, const char *arg, int unset)
  13{
  14        int v;
  15
  16        if (!arg) {
  17                v = unset ? 0 : DEFAULT_ABBREV;
  18        } else {
  19                if (!*arg)
  20                        return error(_("option `%s' expects a numerical value"),
  21                                     opt->long_name);
  22                v = strtol(arg, (char **)&arg, 10);
  23                if (*arg)
  24                        return error(_("option `%s' expects a numerical value"),
  25                                     opt->long_name);
  26                if (v && v < MINIMUM_ABBREV)
  27                        v = MINIMUM_ABBREV;
  28                else if (v > 40)
  29                        v = 40;
  30        }
  31        *(int *)(opt->value) = v;
  32        return 0;
  33}
  34
  35int parse_opt_expiry_date_cb(const struct option *opt, const char *arg,
  36                             int unset)
  37{
  38        if (unset)
  39                arg = "never";
  40        if (parse_expiry_date(arg, (timestamp_t *)opt->value))
  41                die(_("malformed expiration date '%s'"), arg);
  42        return 0;
  43}
  44
  45int parse_opt_color_flag_cb(const struct option *opt, const char *arg,
  46                            int unset)
  47{
  48        int value;
  49
  50        if (!arg)
  51                arg = unset ? "never" : (const char *)opt->defval;
  52        value = git_config_colorbool(NULL, arg);
  53        if (value < 0)
  54                return error(_("option `%s' expects \"always\", \"auto\", or \"never\""),
  55                             opt->long_name);
  56        *(int *)opt->value = value;
  57        return 0;
  58}
  59
  60int parse_opt_verbosity_cb(const struct option *opt, const char *arg,
  61                           int unset)
  62{
  63        int *target = opt->value;
  64
  65        BUG_ON_OPT_ARG(arg);
  66
  67        if (unset)
  68                /* --no-quiet, --no-verbose */
  69                *target = 0;
  70        else if (opt->short_name == 'v') {
  71                if (*target >= 0)
  72                        (*target)++;
  73                else
  74                        *target = 1;
  75        } else {
  76                if (*target <= 0)
  77                        (*target)--;
  78                else
  79                        *target = -1;
  80        }
  81        return 0;
  82}
  83
  84int parse_opt_commits(const struct option *opt, const char *arg, int unset)
  85{
  86        struct object_id oid;
  87        struct commit *commit;
  88
  89        BUG_ON_OPT_NEG(unset);
  90
  91        if (!arg)
  92                return -1;
  93        if (get_oid(arg, &oid))
  94                return error("malformed object name %s", arg);
  95        commit = lookup_commit_reference(the_repository, &oid);
  96        if (!commit)
  97                return error("no such commit %s", arg);
  98        commit_list_insert(commit, opt->value);
  99        return 0;
 100}
 101
 102int parse_opt_object_name(const struct option *opt, const char *arg, int unset)
 103{
 104        struct object_id oid;
 105
 106        if (unset) {
 107                oid_array_clear(opt->value);
 108                return 0;
 109        }
 110        if (!arg)
 111                return -1;
 112        if (get_oid(arg, &oid))
 113                return error(_("malformed object name '%s'"), arg);
 114        oid_array_append(opt->value, &oid);
 115        return 0;
 116}
 117
 118int parse_opt_tertiary(const struct option *opt, const char *arg, int unset)
 119{
 120        int *target = opt->value;
 121
 122        BUG_ON_OPT_ARG(arg);
 123
 124        *target = unset ? 2 : 1;
 125        return 0;
 126}
 127
 128struct option *parse_options_concat(struct option *a, struct option *b)
 129{
 130        struct option *ret;
 131        size_t i, a_len = 0, b_len = 0;
 132
 133        for (i = 0; a[i].type != OPTION_END; i++)
 134                a_len++;
 135        for (i = 0; b[i].type != OPTION_END; i++)
 136                b_len++;
 137
 138        ALLOC_ARRAY(ret, st_add3(a_len, b_len, 1));
 139        for (i = 0; i < a_len; i++)
 140                ret[i] = a[i];
 141        for (i = 0; i < b_len; i++)
 142                ret[a_len + i] = b[i];
 143        ret[a_len + b_len] = b[b_len]; /* final OPTION_END */
 144
 145        return ret;
 146}
 147
 148int parse_opt_string_list(const struct option *opt, const char *arg, int unset)
 149{
 150        struct string_list *v = opt->value;
 151
 152        if (unset) {
 153                string_list_clear(v, 0);
 154                return 0;
 155        }
 156
 157        if (!arg)
 158                return -1;
 159
 160        string_list_append(v, arg);
 161        return 0;
 162}
 163
 164int parse_opt_noop_cb(const struct option *opt, const char *arg, int unset)
 165{
 166        return 0;
 167}
 168
 169/**
 170 * Report that the option is unknown, so that other code can handle
 171 * it. This can be used as a callback together with
 172 * OPTION_LOWLEVEL_CALLBACK to allow an option to be documented in the
 173 * "-h" output even if it's not being handled directly by
 174 * parse_options().
 175 */
 176enum parse_opt_result parse_opt_unknown_cb(struct parse_opt_ctx_t *ctx,
 177                                           const struct option *opt,
 178                                           const char *arg, int unset)
 179{
 180        BUG_ON_OPT_ARG(arg);
 181        return PARSE_OPT_UNKNOWN;
 182}
 183
 184/**
 185 * Recreates the command-line option in the strbuf.
 186 */
 187static int recreate_opt(struct strbuf *sb, const struct option *opt,
 188                const char *arg, int unset)
 189{
 190        strbuf_reset(sb);
 191
 192        if (opt->long_name) {
 193                strbuf_addstr(sb, unset ? "--no-" : "--");
 194                strbuf_addstr(sb, opt->long_name);
 195                if (arg) {
 196                        strbuf_addch(sb, '=');
 197                        strbuf_addstr(sb, arg);
 198                }
 199        } else if (opt->short_name && !unset) {
 200                strbuf_addch(sb, '-');
 201                strbuf_addch(sb, opt->short_name);
 202                if (arg)
 203                        strbuf_addstr(sb, arg);
 204        } else
 205                return -1;
 206
 207        return 0;
 208}
 209
 210/**
 211 * For an option opt, recreates the command-line option in opt->value which
 212 * must be an char* initialized to NULL. This is useful when we need to pass
 213 * the command-line option to another command. Since any previous value will be
 214 * overwritten, this callback should only be used for options where the last
 215 * one wins.
 216 */
 217int parse_opt_passthru(const struct option *opt, const char *arg, int unset)
 218{
 219        static struct strbuf sb = STRBUF_INIT;
 220        char **opt_value = opt->value;
 221
 222        if (recreate_opt(&sb, opt, arg, unset) < 0)
 223                return -1;
 224
 225        free(*opt_value);
 226
 227        *opt_value = strbuf_detach(&sb, NULL);
 228
 229        return 0;
 230}
 231
 232/**
 233 * For an option opt, recreate the command-line option, appending it to
 234 * opt->value which must be a argv_array. This is useful when we need to pass
 235 * the command-line option, which can be specified multiple times, to another
 236 * command.
 237 */
 238int parse_opt_passthru_argv(const struct option *opt, const char *arg, int unset)
 239{
 240        static struct strbuf sb = STRBUF_INIT;
 241        struct argv_array *opt_value = opt->value;
 242
 243        if (recreate_opt(&sb, opt, arg, unset) < 0)
 244                return -1;
 245
 246        argv_array_push(opt_value, sb.buf);
 247
 248        return 0;
 249}