From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from localhost (localhost [127.0.0.1]) by olra.theworths.org (Postfix) with ESMTP id E3B41429E26 for ; Wed, 7 Dec 2011 04:34:58 -0800 (PST) X-Virus-Scanned: Debian amavisd-new at olra.theworths.org X-Spam-Flag: NO X-Spam-Score: -2.3 X-Spam-Level: X-Spam-Status: No, score=-2.3 tagged_above=-999 required=5 tests=[RCVD_IN_DNSWL_MED=-2.3] autolearn=disabled Received: from olra.theworths.org ([127.0.0.1]) by localhost (olra.theworths.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id JefACwciO-wh for ; Wed, 7 Dec 2011 04:34:57 -0800 (PST) Received: from tempo.its.unb.ca (tempo.its.unb.ca [131.202.1.21]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by olra.theworths.org (Postfix) with ESMTPS id 70920431FD0 for ; Wed, 7 Dec 2011 04:34:57 -0800 (PST) Received: from zancas.localnet (fctnnbsc36w-156034079193.pppoe-dynamic.High-Speed.nb.bellaliant.net [156.34.79.193]) (authenticated bits=0) by tempo.its.unb.ca (8.13.8/8.13.8) with ESMTP id pB7CYqZ0007119 (version=TLSv1/SSLv3 cipher=AES256-SHA bits=256 verify=NO); Wed, 7 Dec 2011 08:34:53 -0400 Received: from bremner by zancas.localnet with local (Exim 4.77) (envelope-from ) id 1RYGi4-0007mu-HB; Wed, 07 Dec 2011 08:34:52 -0400 From: David Bremner To: notmuch@notmuchmail.org Subject: [PATCH 1/4] command-line-arguments.[ch]: new argument parsing framework for notmuch. Date: Wed, 7 Dec 2011 08:34:37 -0400 Message-Id: <1323261280-29907-1-git-send-email-david@tethera.net> X-Mailer: git-send-email 1.7.7.3 In-Reply-To: <87iplso9c9.fsf@zancas.localnet> References: <87iplso9c9.fsf@zancas.localnet> Cc: David Bremner X-BeenThere: notmuch@notmuchmail.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: "Use and development of the notmuch mail system." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 07 Dec 2011 12:34:59 -0000 From: David Bremner 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. --- Makefile.local | 1 + command-line-arguments.c | 159 ++++++++++++++++++++++++++++++++++++++++++++++ command-line-arguments.h | 39 +++++++++++ notmuch-client.h | 1 + 4 files changed, 200 insertions(+), 0 deletions(-) create mode 100644 command-line-arguments.c create mode 100644 command-line-arguments.h diff --git a/Makefile.local b/Makefile.local index 15e6d88..28e371a 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 0000000..96ed9ba --- /dev/null +++ b/command-line-arguments.c @@ -0,0 +1,159 @@ +#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->name){ + 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; +} + +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->name) { + if (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; + case NOTMUCH_OPT_POSITION: + case NOTMUCH_OPT_NULL: + default: + INTERNAL_ERROR ("unknown or unhandled option type %d", try->opt_type); + /*UNREACHED*/ + } + } + try++; + } + fprintf (stderr, "Unrecognized option: --%s\n", arg); + return FALSE; +} + +/* + 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) { + + 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 0000000..caebe18 --- /dev/null +++ b/command-line-arguments.h @@ -0,0 +1,39 @@ +#ifndef NOTMUCH_OPTS_H +#define NOTMUCH_OPTS_H + +#include "notmuch.h" + +enum notmuch_opt_type { + NOTMUCH_OPT_NULL = 0, + NOTMUCH_OPT_BOOLEAN, + NOTMUCH_OPT_INT, + NOTMUCH_OPT_KEYWORD, + NOTMUCH_OPT_STRING, + NOTMUCH_OPT_POSITION +}; + +typedef struct notmuch_keyword { + const char *name; + int value; +} notmuch_keyword_t; + +typedef struct notmuch_opt_desc { + const char *name; + int arg_id; + enum notmuch_opt_type opt_type; + struct notmuch_keyword *keywords; + void *output_var; +} notmuch_opt_desc_t; + +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); + +int +parse_arguments(int argc, char **argv, const notmuch_opt_desc_t *options, int opt_index); + +#endif diff --git a/notmuch-client.h b/notmuch-client.h index b50cb38..703f856 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 -- 1.7.7.3