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