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 > 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_dup(const struct option *o)
 163{
 164        struct option *opts;
 165        int nr = 0;
 166
 167        while (o && o->type != OPTION_END) {
 168                nr++;
 169                o++;
 170        }
 171
 172        ALLOC_ARRAY(opts, nr + 1);
 173        memcpy(opts, o - nr, sizeof(*o) * nr);
 174        memset(opts + nr, 0, sizeof(*opts));
 175        opts[nr].type = OPTION_END;
 176        return opts;
 177}
 178
 179struct option *parse_options_concat(struct option *a, struct option *b)
 180{
 181        struct option *ret;
 182        size_t i, a_len = 0, b_len = 0;
 183
 184        for (i = 0; a[i].type != OPTION_END; i++)
 185                a_len++;
 186        for (i = 0; b[i].type != OPTION_END; i++)
 187                b_len++;
 188
 189        ALLOC_ARRAY(ret, st_add3(a_len, b_len, 1));
 190        for (i = 0; i < a_len; i++)
 191                ret[i] = a[i];
 192        for (i = 0; i < b_len; i++)
 193                ret[a_len + i] = b[i];
 194        ret[a_len + b_len] = b[b_len]; /* final OPTION_END */
 195
 196        return ret;
 197}
 198
 199int parse_opt_string_list(const struct option *opt, const char *arg, int unset)
 200{
 201        struct string_list *v = opt->value;
 202
 203        if (unset) {
 204                string_list_clear(v, 0);
 205                return 0;
 206        }
 207
 208        if (!arg)
 209                return -1;
 210
 211        string_list_append(v, arg);
 212        return 0;
 213}
 214
 215int parse_opt_noop_cb(const struct option *opt, const char *arg, int unset)
 216{
 217        return 0;
 218}
 219
 220/**
 221 * Report that the option is unknown, so that other code can handle
 222 * it. This can be used as a callback together with
 223 * OPTION_LOWLEVEL_CALLBACK to allow an option to be documented in the
 224 * "-h" output even if it's not being handled directly by
 225 * parse_options().
 226 */
 227enum parse_opt_result parse_opt_unknown_cb(struct parse_opt_ctx_t *ctx,
 228                                           const struct option *opt,
 229                                           const char *arg, int unset)
 230{
 231        BUG_ON_OPT_ARG(arg);
 232        return PARSE_OPT_UNKNOWN;
 233}
 234
 235/**
 236 * Recreates the command-line option in the strbuf.
 237 */
 238static int recreate_opt(struct strbuf *sb, const struct option *opt,
 239                const char *arg, int unset)
 240{
 241        strbuf_reset(sb);
 242
 243        if (opt->long_name) {
 244                strbuf_addstr(sb, unset ? "--no-" : "--");
 245                strbuf_addstr(sb, opt->long_name);
 246                if (arg) {
 247                        strbuf_addch(sb, '=');
 248                        strbuf_addstr(sb, arg);
 249                }
 250        } else if (opt->short_name && !unset) {
 251                strbuf_addch(sb, '-');
 252                strbuf_addch(sb, opt->short_name);
 253                if (arg)
 254                        strbuf_addstr(sb, arg);
 255        } else
 256                return -1;
 257
 258        return 0;
 259}
 260
 261/**
 262 * For an option opt, recreates the command-line option in opt->value which
 263 * must be an char* initialized to NULL. This is useful when we need to pass
 264 * the command-line option to another command. Since any previous value will be
 265 * overwritten, this callback should only be used for options where the last
 266 * one wins.
 267 */
 268int parse_opt_passthru(const struct option *opt, const char *arg, int unset)
 269{
 270        static struct strbuf sb = STRBUF_INIT;
 271        char **opt_value = opt->value;
 272
 273        if (recreate_opt(&sb, opt, arg, unset) < 0)
 274                return -1;
 275
 276        free(*opt_value);
 277
 278        *opt_value = strbuf_detach(&sb, NULL);
 279
 280        return 0;
 281}
 282
 283/**
 284 * For an option opt, recreate the command-line option, appending it to
 285 * opt->value which must be a argv_array. This is useful when we need to pass
 286 * the command-line option, which can be specified multiple times, to another
 287 * command.
 288 */
 289int parse_opt_passthru_argv(const struct option *opt, const char *arg, int unset)
 290{
 291        static struct strbuf sb = STRBUF_INIT;
 292        struct argv_array *opt_value = opt->value;
 293
 294        if (recreate_opt(&sb, opt, arg, unset) < 0)
 295                return -1;
 296
 297        argv_array_push(opt_value, sb.buf);
 298
 299        return 0;
 300}