From: David Bremner Date: Thu, 1 Dec 2011 00:27:26 +0000 (-0800) Subject: command-line-arguments.[ch]: new argument parsing framework for notmuch. X-Git-Tag: 0.11_rc1~48 X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=commitdiff_plain;h=2cf7b27a0c4b4e746e2e40752c55ddb4d54798b2 command-line-arguments.[ch]: new argument parsing framework for notmuch. As we noticed when Jani kindly converted things to getopt_long, much of the work in argument parsing in notmuch is due to the the key-value style arguments like --format=(raw|json|text). The framework here provides positional arguments, simple switches, and --key=value style arguments that can take a value being an integer, a string, or one of a set of keywords. --- diff --git a/Makefile.local b/Makefile.local index 15e6d882..28e371a8 100644 --- a/Makefile.local +++ b/Makefile.local @@ -295,6 +295,7 @@ clean: distclean: clean notmuch_client_srcs = \ + command-line-arguments.c\ debugger.c \ gmime-filter-reply.c \ gmime-filter-headers.c \ diff --git a/command-line-arguments.c b/command-line-arguments.c new file mode 100644 index 00000000..3aa87aa5 --- /dev/null +++ b/command-line-arguments.c @@ -0,0 +1,155 @@ +#include +#include +#include +#include "error_util.h" +#include "command-line-arguments.h" + +/* + Search the array of keywords for a given argument, assigning the + output variable to the corresponding value. Return FALSE if nothing + matches. +*/ + +static notmuch_bool_t +_process_keyword_arg (const notmuch_opt_desc_t *arg_desc, const char *arg_str) { + + notmuch_keyword_t *keywords = arg_desc->keywords; + + while (keywords->name) { + if (strcmp (arg_str, keywords->name) == 0) { + if (arg_desc->output_var) { + *((int *)arg_desc->output_var) = keywords->value; + } + return TRUE; + } + keywords++; + } + fprintf (stderr, "unknown keyword: %s\n", arg_str); + return FALSE; +} + +/* + Search for the {pos_arg_index}th position argument, return FALSE if + that does not exist. +*/ + +notmuch_bool_t +parse_position_arg (const char *arg_str, int pos_arg_index, + const notmuch_opt_desc_t *arg_desc) { + + int pos_arg_counter = 0; + while (arg_desc->opt_type != NOTMUCH_OPT_END){ + if (arg_desc->opt_type == NOTMUCH_OPT_POSITION) { + if (pos_arg_counter == pos_arg_index) { + if (arg_desc->output_var) { + *((const char **)arg_desc->output_var) = arg_str; + } + return TRUE; + } + pos_arg_counter++; + } + arg_desc++; + } + return FALSE; +} + +/* + * Search for a non-positional (i.e. starting with --) argument matching arg, + * parse a possible value, and assign to *output_var + */ + +notmuch_bool_t +parse_option (const char *arg, + const notmuch_opt_desc_t *options) { + + assert(arg); + assert(options); + + arg += 2; + + const notmuch_opt_desc_t *try = options; + while (try->opt_type != NOTMUCH_OPT_END) { + if (try->name && strncmp (arg, try->name, strlen (try->name)) == 0) { + char next = arg[strlen (try->name)]; + const char *value= arg+strlen(try->name)+1; + + char *endptr; + + /* Everything but boolean arguments (switches) needs a + * delimiter, and a non-zero length value + */ + + if (try->opt_type != NOTMUCH_OPT_BOOLEAN) { + if (next != '=' && next != ':') return FALSE; + if (value[0] == 0) return FALSE; + } else { + if (next != 0) return FALSE; + } + + if (try->output_var == NULL) + INTERNAL_ERROR ("output pointer NULL for option %s", try->name); + + switch (try->opt_type) { + case NOTMUCH_OPT_KEYWORD: + return _process_keyword_arg (try, value); + break; + case NOTMUCH_OPT_BOOLEAN: + *((notmuch_bool_t *)try->output_var) = TRUE; + return TRUE; + break; + case NOTMUCH_OPT_INT: + *((int *)try->output_var) = strtol (value, &endptr, 10); + return (*endptr == 0); + break; + case NOTMUCH_OPT_STRING: + *((const char **)try->output_var) = value; + return TRUE; + break; + case NOTMUCH_OPT_POSITION: + case NOTMUCH_OPT_END: + default: + INTERNAL_ERROR ("unknown or unhandled option type %d", try->opt_type); + /*UNREACHED*/ + } + } + try++; + } + fprintf (stderr, "Unrecognized option: --%s\n", arg); + return FALSE; +} + +/* See command-line-arguments.h for description */ +int +parse_arguments (int argc, char **argv, + const notmuch_opt_desc_t *options, int opt_index) { + + int pos_arg_index = 0; + notmuch_bool_t more_args = TRUE; + + while (more_args && opt_index < argc) { + if (strncmp (argv[opt_index],"--",2) != 0) { + + more_args = parse_position_arg (argv[opt_index], pos_arg_index, options); + + if (more_args) { + pos_arg_index++; + opt_index++; + } + + } else { + + if (strlen (argv[opt_index]) == 2) + return opt_index+1; + + more_args = parse_option (argv[opt_index], options); + if (more_args) { + opt_index++; + } else { + opt_index = -1; + } + + } + } + + return opt_index; +} diff --git a/command-line-arguments.h b/command-line-arguments.h new file mode 100644 index 00000000..af8b1ceb --- /dev/null +++ b/command-line-arguments.h @@ -0,0 +1,80 @@ +#ifndef NOTMUCH_OPTS_H +#define NOTMUCH_OPTS_H + +#include "notmuch.h" + +enum notmuch_opt_type { + NOTMUCH_OPT_END = 0, + NOTMUCH_OPT_BOOLEAN, /* --verbose */ + NOTMUCH_OPT_INT, /* --frob=8 */ + NOTMUCH_OPT_KEYWORD, /* --format=raw|json|text */ + NOTMUCH_OPT_STRING, /* --file=/tmp/gnarf.txt */ + NOTMUCH_OPT_POSITION /* notmuch dump pos_arg */ +}; + +/* + * Describe one of the possibilities for a keyword option + * 'value' will be copied to the output variable + */ + +typedef struct notmuch_keyword { + const char *name; + int value; +} notmuch_keyword_t; + +/* + * Describe one option. + * + * First two parameters are mandatory. + * + * name is mandatory _except_ for positional arguments. + * + * arg_id is currently unused, but could define short arguments. + * + * keywords is a (possibly NULL) pointer to an array of keywords + */ +typedef struct notmuch_opt_desc { + enum notmuch_opt_type opt_type; + void *output_var; + const char *name; + int arg_id; + struct notmuch_keyword *keywords; +} notmuch_opt_desc_t; + + +/* + This is the main entry point for command line argument parsing. + + Parse command line arguments according to structure options, + starting at position opt_index. + + All output of parsed values is via pointers in options. + + Parsing stops at -- (consumed) or at the (k+1)st argument + not starting with -- (a "positional argument") if options contains + k positional argument descriptors. + + Returns the index of first non-parsed argument, or -1 in case of error. + +*/ +int +parse_arguments (int argc, char **argv, const notmuch_opt_desc_t *options, int opt_index); + +/* + * If the argument parsing loop provided by parse_arguments is not + * flexible enough, then the user might be interested in the following + * routines, but note that the API to parse_option might have to + * change. See command-line-arguments.c for descriptions of these + * functions. + */ + +notmuch_bool_t +parse_option (const char *arg, const notmuch_opt_desc_t* options); + +notmuch_bool_t +parse_position_arg (const char *arg, + int position_arg_index, + const notmuch_opt_desc_t* options); + + +#endif diff --git a/notmuch-client.h b/notmuch-client.h index b50cb38b..703f8561 100644 --- a/notmuch-client.h +++ b/notmuch-client.h @@ -238,4 +238,5 @@ notmuch_config_set_maildir_synchronize_flags (notmuch_config_t *config, notmuch_bool_t debugger_is_active (void); +#include "command-line-arguments.h" #endif