f1a5b2324337fb2ceb78f6fcde64133f8f12454c
[notmuch] / 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 /*
8   Search the array of keywords for a given argument, assigning the
9   output variable to the corresponding value.  Return FALSE if nothing
10   matches.
11 */
12
13 static notmuch_bool_t
14 _process_keyword_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str) {
15
16     const notmuch_keyword_t *keywords = arg_desc->keywords;
17
18     if (next == '\0') {
19         /* No keyword given */
20         arg_str = "";
21     }
22
23     while (keywords->name) {
24         if (strcmp (arg_str, keywords->name) == 0) {
25             if (arg_desc->opt_flags)
26                 *arg_desc->opt_flags |= keywords->value;
27             else
28                 *arg_desc->opt_keyword = keywords->value;
29             return TRUE;
30         }
31         keywords++;
32     }
33     if (next != '\0')
34         fprintf (stderr, "Unknown keyword argument \"%s\" for option \"%s\".\n", arg_str, arg_desc->name);
35     else
36         fprintf (stderr, "Option \"%s\" needs a keyword argument.\n", arg_desc->name);
37     return FALSE;
38 }
39
40 static notmuch_bool_t
41 _process_boolean_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str) {
42
43     if (next == '\0') {
44         *arg_desc->opt_bool = TRUE;
45         return TRUE;
46     }
47     if (strcmp (arg_str, "false") == 0) {
48         *arg_desc->opt_bool = FALSE;
49         return TRUE;
50     }
51     if (strcmp (arg_str, "true") == 0) {
52         *arg_desc->opt_bool = TRUE;
53         return TRUE;
54     }
55     fprintf (stderr, "Unknown argument \"%s\" for (boolean) option \"%s\".\n", arg_str, arg_desc->name);
56     return FALSE;
57 }
58
59 static notmuch_bool_t
60 _process_int_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str) {
61
62     char *endptr;
63     if (next == '\0' || arg_str[0] == '\0') {
64         fprintf (stderr, "Option \"%s\" needs an integer argument.\n", arg_desc->name);
65         return FALSE;
66     }
67
68     *arg_desc->opt_int = strtol (arg_str, &endptr, 10);
69     if (*endptr == '\0')
70         return TRUE;
71
72     fprintf (stderr, "Unable to parse argument \"%s\" for option \"%s\" as an integer.\n",
73              arg_str, arg_desc->name);
74     return FALSE;
75 }
76
77 static notmuch_bool_t
78 _process_string_arg (const notmuch_opt_desc_t *arg_desc, char next, const char *arg_str) {
79
80     if (next == '\0') {
81         fprintf (stderr, "Option \"%s\" needs a string argument.\n", arg_desc->name);
82         return FALSE;
83     }
84     if (arg_str[0] == '\0') {
85         fprintf (stderr, "String argument for option \"%s\" must be non-empty.\n", arg_desc->name);
86         return FALSE;
87     }
88     *arg_desc->opt_string = arg_str;
89     return TRUE;
90 }
91
92 /* Return number of non-NULL opt_* fields in opt_desc. */
93 static int _opt_set_count (const notmuch_opt_desc_t *opt_desc)
94 {
95     return
96         !!opt_desc->opt_inherit +
97         !!opt_desc->opt_bool +
98         !!opt_desc->opt_int +
99         !!opt_desc->opt_keyword +
100         !!opt_desc->opt_flags +
101         !!opt_desc->opt_string +
102         !!opt_desc->opt_position;
103 }
104
105 /* Return TRUE if opt_desc is valid. */
106 static notmuch_bool_t _opt_valid (const notmuch_opt_desc_t *opt_desc)
107 {
108     int n = _opt_set_count (opt_desc);
109
110     if (n > 1)
111         INTERNAL_ERROR ("more than one non-NULL opt_* field for argument \"%s\"",
112                         opt_desc->name);
113
114     return n > 0;
115 }
116
117 /*
118    Search for the {pos_arg_index}th position argument, return FALSE if
119    that does not exist.
120 */
121
122 notmuch_bool_t
123 parse_position_arg (const char *arg_str, int pos_arg_index,
124                     const notmuch_opt_desc_t *arg_desc) {
125
126     int pos_arg_counter = 0;
127     while (_opt_valid (arg_desc)) {
128         if (arg_desc->opt_position) {
129             if (pos_arg_counter == pos_arg_index) {
130                 *arg_desc->opt_position = arg_str;
131                 return TRUE;
132             }
133             pos_arg_counter++;
134         }
135         arg_desc++;
136     }
137     return FALSE;
138 }
139
140 /*
141  * Search for a non-positional (i.e. starting with --) argument matching arg,
142  * parse a possible value, and assign to *output_var
143  */
144
145 int
146 parse_option (int argc, char **argv, const notmuch_opt_desc_t *options, int opt_index)
147 {
148     assert(argv);
149
150     const char *_arg = argv[opt_index];
151
152     assert(_arg);
153     assert(options);
154
155     const char *arg = _arg + 2; /* _arg starts with -- */
156     const notmuch_opt_desc_t *try;
157
158     const char *next_arg = NULL;
159     if (opt_index < argc - 1  && strncmp (argv[opt_index + 1], "--", 2) != 0)
160         next_arg = argv[opt_index + 1];
161
162     for (try = options; _opt_valid (try); try++) {
163         if (try->opt_inherit) {
164             int new_index = parse_option (argc, argv, try->opt_inherit, opt_index);
165             if (new_index >= 0)
166                 return new_index;
167         }
168
169         if (! try->name)
170             continue;
171
172         if (strncmp (arg, try->name, strlen (try->name)) != 0)
173             continue;
174
175         char next = arg[strlen (try->name)];
176         const char *value = arg + strlen(try->name) + 1;
177
178         /*
179          * If we have not reached the end of the argument (i.e. the
180          * next character is not a space or delimiter) then the
181          * argument could still match a longer option name later in
182          * the option table.
183          */
184         if (next != '=' && next != ':' && next != '\0')
185             continue;
186
187         if (next == '\0' && next_arg != NULL && ! try->opt_bool) {
188             next = ' ';
189             value = next_arg;
190             opt_index ++;
191         }
192
193         notmuch_bool_t opt_status = FALSE;
194         if (try->opt_keyword || try->opt_flags)
195             opt_status = _process_keyword_arg (try, next, value);
196         else if (try->opt_bool)
197             opt_status = _process_boolean_arg (try, next, value);
198         else if (try->opt_int)
199             opt_status = _process_int_arg (try, next, value);
200         else if (try->opt_string)
201             opt_status = _process_string_arg (try, next, value);
202         else
203             INTERNAL_ERROR ("unknown or unhandled option \"%s\"", try->name);
204
205         if (opt_status)
206             return opt_index+1;
207         else
208             return -1;
209     }
210     return -1;
211 }
212
213 /* See command-line-arguments.h for description */
214 int
215 parse_arguments (int argc, char **argv,
216                  const notmuch_opt_desc_t *options, int opt_index) {
217
218     int pos_arg_index = 0;
219     notmuch_bool_t more_args = TRUE;
220
221     while (more_args && opt_index < argc) {
222         if (strncmp (argv[opt_index],"--",2) != 0) {
223
224             more_args = parse_position_arg (argv[opt_index], pos_arg_index, options);
225
226             if (more_args) {
227                 pos_arg_index++;
228                 opt_index++;
229             }
230
231         } else {
232             int prev_opt_index = opt_index;
233
234             if (strlen (argv[opt_index]) == 2)
235                 return opt_index+1;
236
237             opt_index = parse_option (argc, argv, options, opt_index);
238             if (opt_index < 0) {
239                 fprintf (stderr, "Unrecognized option: %s\n", argv[prev_opt_index]);
240                 more_args = FALSE;
241             }
242         }
243     }
244
245     return opt_index;
246 }