git.cworth.org Git - notmuch-old/blob - command-line-arguments.c

   1 #include <assert.h>
   2 #include <string.h>
   3 #include <stdio.h>
   4 #include "error_util.h"
   5 #include "command-line-arguments.h"
   6
   7 typedef enum {
   8     OPT_FAILED,         /* false */
   9     OPT_OK,             /* good */
  10     OPT_GIVEBACK,       /* pop one of the arguments you thought you were getting off the stack */
  11 } opt_handled;
  12
  13 /*
  14  * Search the array of keywords for a given argument, assigning the
  15  * output variable to the corresponding value.  Return false if nothing
  16  * matches.
  17  */
  18
  19 static opt_handled
  20 _process_keyword_arg (const notmuch_opt_desc_t *arg_desc, char next,
  21                       const char *arg_str, bool negate)
  22 {
  23     const notmuch_keyword_t *keywords;
  24
  25     if (next == '\0') {
  26         /* No keyword given */
  27         arg_str = "";
  28     }
  29
  30     for (keywords = arg_desc->keywords; keywords->name; keywords++) {
  31         if (strcmp (arg_str, keywords->name) != 0)
  32             continue;
  33
  34         if (arg_desc->opt_flags && negate)
  35             *arg_desc->opt_flags &= ~keywords->value;
  36         else if (arg_desc->opt_flags)
  37             *arg_desc->opt_flags |= keywords->value;
  38         else
  39             *arg_desc->opt_keyword = keywords->value;
  40
  41         return OPT_OK;
  42     }
  43
  44     if (arg_desc->opt_keyword && arg_desc->keyword_no_arg_value && next != ':' && next != '=') {
  45         for (keywords = arg_desc->keywords; keywords->name; keywords++) {
  46             if (strcmp (arg_desc->keyword_no_arg_value, keywords->name) != 0)
  47                 continue;
  48
  49             *arg_desc->opt_keyword = keywords->value;
  50             fprintf (stderr, "Warning: No known keyword option given for \"%s\", choosing value \"%s\"."
  51                      "  Please specify the argument explicitly!\n", arg_desc->name, arg_desc->keyword_no_arg_value);
  52
  53             return OPT_GIVEBACK;
  54         }
  55         fprintf (stderr, "No matching keyword for option \"%s\" and default value \"%s\" is invalid.\n", arg_str, arg_desc->name);
  56         return OPT_FAILED;
  57     }
  58
  59     if (next != '\0')
  60         fprintf (stderr, "Unknown keyword argument \"%s\" for option \"%s\".\n", arg_str, arg_desc->name);
  61     else
  62         fprintf (stderr, "Option \"%s\" needs a keyword argument.\n", arg_desc->name);
  63     return OPT_FAILED;
  64 }
  65
  66 static opt_handled
  67 _process_boolean_arg (const notmuch_opt_desc_t *arg_desc, char next,
  68                       const char *arg_str, bool negate)
  69 {
  70     bool value;
  71
  72     if (next == '\0' || strcmp (arg_str, "true") == 0) {
  73         value = true;
  74     } else if (strcmp (arg_str, "false") == 0) {
  75         value = false;
  76     } else {
  77         fprintf (stderr, "Unknown argument \"%s\" for (boolean) option \"%s\".\n", arg_str, arg_desc->name);
  78         return OPT_FAILED;
  79     }
  80
  81     *arg_desc->opt_bool = negate ? (! value) : value;
  82
  83     return OPT_OK;
  84 }
  85
  86 static opt_handled
  87 _process_int_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str)
  88 {
  89
  90     char *endptr;
  91
  92     if (next == '\0' || arg_str[0] == '\0') {
  93         fprintf (stderr, "Option \"%s\" needs an integer argument.\n", arg_desc->name);
  94         return OPT_FAILED;
  95     }
  96
  97     *arg_desc->opt_int = strtol (arg_str, &endptr, 10);
  98     if (*endptr == '\0')
  99         return OPT_OK;
 100
 101     fprintf (stderr, "Unable to parse argument \"%s\" for option \"%s\" as an integer.\n",
 102              arg_str, arg_desc->name);
 103     return OPT_FAILED;
 104 }
 105
 106 static opt_handled
 107 _process_string_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str)
 108 {
 109
 110     if (next == '\0') {
 111         fprintf (stderr, "Option \"%s\" needs a string argument.\n", arg_desc->name);
 112         return OPT_FAILED;
 113     }
 114     if (arg_str[0] == '\0' && ! arg_desc->allow_empty) {
 115         fprintf (stderr, "String argument for option \"%s\" must be non-empty.\n", arg_desc->name);
 116         return OPT_FAILED;
 117     }
 118     *arg_desc->opt_string = arg_str;
 119     return OPT_OK;
 120 }
 121
 122 /* Return number of non-NULL opt_* fields in opt_desc. */
 123 static int
 124 _opt_set_count (const notmuch_opt_desc_t *opt_desc)
 125 {
 126     return
 127         (bool) opt_desc->opt_inherit +
 128         (bool) opt_desc->opt_bool +
 129         (bool) opt_desc->opt_int +
 130         (bool) opt_desc->opt_keyword +
 131         (bool) opt_desc->opt_flags +
 132         (bool) opt_desc->opt_string +
 133         (bool) opt_desc->opt_position;
 134 }
 135
 136 /* Return true if opt_desc is valid. */
 137 static bool
 138 _opt_valid (const notmuch_opt_desc_t *opt_desc)
 139 {
 140     int n = _opt_set_count (opt_desc);
 141
 142     if (n > 1)
 143         INTERNAL_ERROR ("more than one non-NULL opt_* field for argument \"%s\"",
 144                         opt_desc->name);
 145
 146     return n > 0;
 147 }
 148
 149 /*
 150  * Search for the {pos_arg_index}th position argument, return false if
 151  * that does not exist.
 152  */
 153
 154 bool
 155 parse_position_arg (const char *arg_str, int pos_arg_index,
 156                     const notmuch_opt_desc_t *arg_desc)
 157 {
 158
 159     int pos_arg_counter = 0;
 160
 161     while (_opt_valid (arg_desc)) {
 162         if (arg_desc->opt_position) {
 163             if (pos_arg_counter == pos_arg_index) {
 164                 *arg_desc->opt_position = arg_str;
 165                 if (arg_desc->present)
 166                     *arg_desc->present = true;
 167                 return true;
 168             }
 169             pos_arg_counter++;
 170         }
 171         arg_desc++;
 172     }
 173     return false;
 174 }
 175
 176 #define NEGATIVE_PREFIX "no-"
 177
 178 /*
 179  * Search for a non-positional (i.e. starting with --) argument matching arg,
 180  * parse a possible value, and assign to *output_var
 181  */
 182
 183 int
 184 parse_option (int argc, char **argv, const notmuch_opt_desc_t *options, int opt_index)
 185 {
 186     assert (argv);
 187
 188     const char *_arg = argv[opt_index];
 189
 190     assert (_arg);
 191     assert (options);
 192
 193     const char *arg = _arg + 2; /* _arg starts with -- */
 194     const char *negative_arg = NULL;
 195
 196     /* See if this is a --no-argument */
 197     if (strlen (arg) > strlen (NEGATIVE_PREFIX) &&
 198         strncmp (arg, NEGATIVE_PREFIX, strlen (NEGATIVE_PREFIX)) == 0) {
 199         negative_arg = arg + strlen (NEGATIVE_PREFIX);
 200     }
 201
 202     const notmuch_opt_desc_t *try;
 203
 204     const char *next_arg = NULL;
 205     if (opt_index < argc - 1  && strncmp (argv[opt_index + 1], "--", 2) != 0)
 206         next_arg = argv[opt_index + 1];
 207
 208     for (try = options; _opt_valid (try); try++) {
 209         if (try->opt_inherit) {
 210             int new_index = parse_option (argc, argv, try->opt_inherit, opt_index);
 211             if (new_index >= 0)
 212                 return new_index;
 213         }
 214
 215         if (! try->name)
 216             continue;
 217
 218         char next;
 219         const char *value;
 220         bool negate = false;
 221
 222         if (strncmp (arg, try->name, strlen (try->name)) == 0) {
 223             next = arg[strlen (try->name)];
 224             value = arg + strlen (try->name) + 1;
 225         } else if (negative_arg && (try->opt_bool || try->opt_flags) &&
 226                    strncmp (negative_arg, try->name, strlen (try->name)) == 0) {
 227             next = negative_arg[strlen (try->name)];
 228             value = negative_arg + strlen (try->name) + 1;
 229             /* The argument part of --no-argument matches, negate the result. */
 230             negate = true;
 231         } else {
 232             continue;
 233         }
 234
 235         /*
 236          * If we have not reached the end of the argument (i.e. the
 237          * next character is not a space or delimiter) then the
 238          * argument could still match a longer option name later in
 239          * the option table.
 240          */
 241         if (next != '=' && next != ':' && next != '\0')
 242             continue;
 243
 244         bool lookahead = (next == '\0' && next_arg != NULL && ! try->opt_bool);
 245
 246         if (lookahead) {
 247             next = ' ';
 248             value = next_arg;
 249             opt_index++;
 250         }
 251
 252         opt_handled opt_status = OPT_FAILED;
 253         if (try->opt_keyword || try->opt_flags)
 254             opt_status = _process_keyword_arg (try, next, value, negate);
 255         else if (try->opt_bool)
 256             opt_status = _process_boolean_arg (try, next, value, negate);
 257         else if (try->opt_int)
 258             opt_status = _process_int_arg (try, next, value);
 259         else if (try->opt_string)
 260             opt_status = _process_string_arg (try, next, value);
 261         else
 262             INTERNAL_ERROR ("unknown or unhandled option \"%s\"", try->name);
 263
 264         if (opt_status == OPT_FAILED)
 265             return -1;
 266
 267         if (lookahead && opt_status == OPT_GIVEBACK)
 268             opt_index--;
 269
 270         if (try->present)
 271             *try->present = true;
 272
 273         return opt_index + 1;
 274     }
 275     return -1;
 276 }
 277
 278 /* See command-line-arguments.h for description */
 279 int
 280 parse_arguments (int argc, char **argv,
 281                  const notmuch_opt_desc_t *options, int opt_index)
 282 {
 283
 284     int pos_arg_index = 0;
 285     bool more_args = true;
 286
 287     while (more_args && opt_index < argc) {
 288         if (strncmp (argv[opt_index], "--", 2) != 0) {
 289
 290             more_args = parse_position_arg (argv[opt_index], pos_arg_index, options);
 291
 292             if (more_args) {
 293                 pos_arg_index++;
 294                 opt_index++;
 295             }
 296
 297         } else {
 298             int prev_opt_index = opt_index;
 299
 300             if (strlen (argv[opt_index]) == 2)
 301                 return opt_index + 1;
 302
 303             opt_index = parse_option (argc, argv, options, opt_index);
 304             if (opt_index < 0) {
 305                 fprintf (stderr, "Unrecognized option: %s\n", argv[prev_opt_index]);
 306                 more_args = false;
 307             }
 308         }
 309     }
 310
 311     return opt_index;
 312 }