Andrew's git / gitweb.git / parse-options-cb.c
?
parse-options-cb.con commit Merge branch 'sg/t5551-fetch-smart-error-is-translated' into maint (0a2e838)
   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 > the_hash_algo->hexsz)
  29                        v = the_hash_algo->hexsz;
  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_commit(const struct option *opt, const char *arg, int unset)
 103{
 104        struct object_id oid;
 105        struct commit *commit;
 106        struct commit **target = opt->value;
 107
 108        if (!arg)
 109                return -1;
 110        if (get_oid(arg, &oid))
 111                return error("malformed object name %s", arg);
 112        commit = lookup_commit_reference(the_repository, &oid);
 113        if (!commit)
 114                return error("no such commit %s", arg);
 115        *target = commit;
 116        return 0;
 117}
 118
 119int parse_opt_object_name(const struct option *opt, const char *arg, int unset)
 120{
 121        struct object_id oid;
 122
 123        if (unset) {
 124                oid_array_clear(opt->value);
 125                return 0;
 126        }
 127        if (!arg)
 128                return -1;
 129        if (get_oid(arg, &oid))
 130                return error(_("malformed object name '%s'"), arg);
 131        oid_array_append(opt->value, &oid);
 132        return 0;
 133}
 134
 135int parse_opt_object_id(const struct option *opt, const char *arg, int unset)
 136{
 137        struct object_id oid;
 138        struct object_id *target = opt->value;
 139
 140        if (unset) {
 141                *target = null_oid;
 142                return 0;
 143        }
 144        if (!arg)
 145                return -1;
 146        if (get_oid(arg, &oid))
 147                return error(_("malformed object name '%s'"), arg);
 148        *target = oid;
 149        return 0;
 150}
 151
 152int parse_opt_tertiary(const struct option *opt, const char *arg, int unset)
 153{
 154        int *target = opt->value;
 155
 156        BUG_ON_OPT_ARG(arg);
 157
 158        *target = unset ? 2 : 1;
 159        return 0;
 160}
 161
 162struct option *parse_options_concat(struct option *a, struct option *b)
 163{
 164        struct option *ret;
 165        size_t i, a_len = 0, b_len = 0;
 166
 167        for (i = 0; a[i].type != OPTION_END; i++)
 168                a_len++;
 169        for (i = 0; b[i].type != OPTION_END; i++)
 170                b_len++;
 171
 172        ALLOC_ARRAY(ret, st_add3(a_len, b_len, 1));
 173        for (i = 0; i < a_len; i++)
 174                ret[i] = a[i];
 175        for (i = 0; i < b_len; i++)
 176                ret[a_len + i] = b[i];
 177        ret[a_len + b_len] = b[b_len]; /* final OPTION_END */
 178
 179        return ret;
 180}
 181
 182int parse_opt_string_list(const struct option *opt, const char *arg, int unset)
 183{
 184        struct string_list *v = opt->value;
 185
 186        if (unset) {
 187                string_list_clear(v, 0);
 188                return 0;
 189        }
 190
 191        if (!arg)
 192                return -1;
 193
 194        string_list_append(v, arg);
 195        return 0;
 196}
 197
 198int parse_opt_noop_cb(const struct option *opt, const char *arg, int unset)
 199{
 200        return 0;
 201}
 202
 203/**
 204 * Report that the option is unknown, so that other code can handle
 205 * it. This can be used as a callback together with
 206 * OPTION_LOWLEVEL_CALLBACK to allow an option to be documented in the
 207 * "-h" output even if it's not being handled directly by
 208 * parse_options().
 209 */
 210enum parse_opt_result parse_opt_unknown_cb(struct parse_opt_ctx_t *ctx,
 211                                           const struct option *opt,
 212                                           const char *arg, int unset)
 213{
 214        BUG_ON_OPT_ARG(arg);
 215        return PARSE_OPT_UNKNOWN;
 216}
 217
 218/**
 219 * Recreates the command-line option in the strbuf.
 220 */
 221static int recreate_opt(struct strbuf *sb, const struct option *opt,
 222                const char *arg, int unset)
 223{
 224        strbuf_reset(sb);
 225
 226        if (opt->long_name) {
 227                strbuf_addstr(sb, unset ? "--no-" : "--");
 228                strbuf_addstr(sb, opt->long_name);
 229                if (arg) {
 230                        strbuf_addch(sb, '=');
 231                        strbuf_addstr(sb, arg);
 232                }
 233        } else if (opt->short_name && !unset) {
 234                strbuf_addch(sb, '-');
 235                strbuf_addch(sb, opt->short_name);
 236                if (arg)
 237                        strbuf_addstr(sb, arg);
 238        } else
 239                return -1;
 240
 241        return 0;
 242}
 243
 244/**
 245 * For an option opt, recreates the command-line option in opt->value which
 246 * must be an char* initialized to NULL. This is useful when we need to pass
 247 * the command-line option to another command. Since any previous value will be
 248 * overwritten, this callback should only be used for options where the last
 249 * one wins.
 250 */
 251int parse_opt_passthru(const struct option *opt, const char *arg, int unset)
 252{
 253        static struct strbuf sb = STRBUF_INIT;
 254        char **opt_value = opt->value;
 255
 256        if (recreate_opt(&sb, opt, arg, unset) < 0)
 257                return -1;
 258
 259        free(*opt_value);
 260
 261        *opt_value = strbuf_detach(&sb, NULL);
 262
 263        return 0;
 264}
 265
 266/**
 267 * For an option opt, recreate the command-line option, appending it to
 268 * opt->value which must be a argv_array. This is useful when we need to pass
 269 * the command-line option, which can be specified multiple times, to another
 270 * command.
 271 */
 272int parse_opt_passthru_argv(const struct option *opt, const char *arg, int unset)
 273{
 274        static struct strbuf sb = STRBUF_INIT;
 275        struct argv_array *opt_value = opt->value;
 276
 277        if (recreate_opt(&sb, opt, arg, unset) < 0)
 278                return -1;
 279
 280        argv_array_push(opt_value, sb.buf);
 281
 282        return 0;
 283}