1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
13 #include <ecoli_malloc.h>
14 #include <ecoli_log.h>
15 #include <ecoli_string.h>
16 #include <ecoli_test.h>
17 #include <ecoli_strvec.h>
18 #include <ecoli_node.h>
19 #include <ecoli_parsed.h>
20 #include <ecoli_completed.h>
21 #include <ecoli_node_seq.h>
22 #include <ecoli_node_str.h>
23 #include <ecoli_node_option.h>
24 #include <ecoli_node_sh_lex.h>
26 EC_LOG_TYPE_REGISTER(node_sh_lex);
28 struct ec_node_sh_lex {
30 struct ec_node *child;
33 static size_t eat_spaces(const char *str)
38 while (isblank(str[i]))
45 * Allocate a new string which is a copy of the input string with quotes
46 * removed. If quotes are not closed properly, set missing_quote to the
49 static char *unquote_str(const char *str, size_t n, int allow_missing_quote,
52 unsigned s = 1, d = 0;
63 /* copy string and remove quotes */
64 while (s < n && d < n && str[s] != '\0') {
65 if (str[s] == '\\' && str[s+1] == quote) {
70 if (str[s] == '\\' && str[s+1] == '\\') {
75 if (str[s] == quote) {
83 /* not enough room in dst buffer (should not happen) */
90 /* quote not closed */
92 if (missing_quote != NULL)
93 *missing_quote = str[0];
94 if (allow_missing_quote == 0) {
105 static size_t eat_quoted_str(const char *str)
110 while (str[i] != '\0') {
111 if (str[i] != '\\' && str[i+1] == quote)
116 /* unclosed quote, will be detected later */
120 static size_t eat_str(const char *str)
124 /* eat chars until we find a quote, space, or end of string */
125 while (!isblank(str[i]) && str[i] != '\0' &&
126 str[i] != '"' && str[i] != '\'')
132 static struct ec_strvec *tokenize(const char *str, int completion,
133 int allow_missing_quote, char *missing_quote)
135 struct ec_strvec *strvec = NULL;
136 size_t off = 0, len, suboff, sublen;
137 char *word = NULL, *concat = NULL, *tmp;
138 int last_is_space = 1;
140 strvec = ec_strvec();
144 while (str[off] != '\0') {
145 if (missing_quote != NULL)
146 *missing_quote = '\0';
147 len = eat_spaces(&str[off]);
154 while (str[suboff] != '\0') {
155 if (missing_quote != NULL)
156 *missing_quote = '\0';
158 if (str[suboff] == '"' || str[suboff] == '\'') {
159 sublen = eat_quoted_str(&str[suboff]);
160 word = unquote_str(&str[suboff], sublen,
161 allow_missing_quote, missing_quote);
163 sublen = eat_str(&str[suboff]);
166 word = ec_strndup(&str[suboff], sublen);
175 if (concat == NULL) {
179 tmp = ec_realloc(concat, len + 1);
183 strcat(concat, word);
189 if (concat != NULL) {
190 if (ec_strvec_add(strvec, concat) < 0)
199 /* in completion mode, append an empty string in the vector if
200 * the input string ends with space */
201 if (completion && last_is_space) {
202 if (ec_strvec_add(strvec, "") < 0)
211 ec_strvec_free(strvec);
216 ec_node_sh_lex_parse(const struct ec_node *gen_node,
217 struct ec_parsed *state,
218 const struct ec_strvec *strvec)
220 struct ec_node_sh_lex *node = (struct ec_node_sh_lex *)gen_node;
221 struct ec_strvec *new_vec = NULL;
222 struct ec_parsed *child_parsed;
226 if (ec_strvec_len(strvec) == 0) {
227 new_vec = ec_strvec();
229 str = ec_strvec_val(strvec, 0);
230 new_vec = tokenize(str, 0, 0, NULL);
232 if (new_vec == NULL) {
234 ret = EC_PARSED_NOMATCH;
240 ret = ec_node_parse_child(node->child, state, new_vec);
244 if ((unsigned)ret == ec_strvec_len(new_vec)) {
246 } else if (ret != EC_PARSED_NOMATCH) {
247 child_parsed = ec_parsed_get_last_child(state);
248 ec_parsed_unlink_child(state, child_parsed);
249 ec_parsed_free(child_parsed);
250 ret = EC_PARSED_NOMATCH;
253 ec_strvec_free(new_vec);
259 ec_strvec_free(new_vec);
264 ec_node_sh_lex_complete(const struct ec_node *gen_node,
265 struct ec_completed *completed,
266 const struct ec_strvec *strvec)
268 struct ec_node_sh_lex *node = (struct ec_node_sh_lex *)gen_node;
269 struct ec_completed *tmp_completed = NULL;
270 struct ec_strvec *new_vec = NULL;
271 struct ec_completed_iter *iter = NULL;
272 struct ec_completed_item *item = NULL;
273 char *new_str = NULL;
275 char missing_quote = '\0';
278 if (ec_strvec_len(strvec) != 1)
281 str = ec_strvec_val(strvec, 0);
282 new_vec = tokenize(str, 1, 1, &missing_quote);
286 /* we will store the completions in a temporary struct, because
287 * we want to update them (ex: add missing quotes) */
288 tmp_completed = ec_completed(ec_completed_get_state(completed));
289 if (tmp_completed == NULL)
292 ret = ec_node_complete_child(node->child, tmp_completed, new_vec);
296 /* add missing quote for full completions */
297 if (missing_quote != '\0') {
298 iter = ec_completed_iter(tmp_completed, EC_COMP_FULL);
301 while ((item = ec_completed_iter_next(iter)) != NULL) {
302 str = ec_completed_item_get_str(item);
303 if (ec_asprintf(&new_str, "%c%s%c", missing_quote, str,
304 missing_quote) < 0) {
308 if (ec_completed_item_set_str(item, new_str) < 0)
313 str = ec_completed_item_get_completion(item);
314 if (ec_asprintf(&new_str, "%s%c", str,
315 missing_quote) < 0) {
319 if (ec_completed_item_set_completion(item, new_str) < 0)
326 ec_completed_iter_free(iter);
327 ec_strvec_free(new_vec);
329 ec_completed_merge(completed, tmp_completed);
334 ec_completed_free(tmp_completed);
335 ec_completed_iter_free(iter);
336 ec_strvec_free(new_vec);
342 static void ec_node_sh_lex_free_priv(struct ec_node *gen_node)
344 struct ec_node_sh_lex *node = (struct ec_node_sh_lex *)gen_node;
346 ec_node_free(node->child);
349 static struct ec_node_type ec_node_sh_lex_type = {
351 .parse = ec_node_sh_lex_parse,
352 .complete = ec_node_sh_lex_complete,
353 .size = sizeof(struct ec_node_sh_lex),
354 .free_priv = ec_node_sh_lex_free_priv,
357 EC_NODE_TYPE_REGISTER(ec_node_sh_lex_type);
359 struct ec_node *ec_node_sh_lex(const char *id, struct ec_node *child)
361 struct ec_node_sh_lex *node = NULL;
366 node = (struct ec_node_sh_lex *)__ec_node(&ec_node_sh_lex_type, id);
377 /* LCOV_EXCL_START */
378 static int ec_node_sh_lex_testcase(void)
380 struct ec_node *node;
383 node = ec_node_sh_lex(EC_NO_ID,
384 EC_NODE_SEQ(EC_NO_ID,
385 ec_node_str(EC_NO_ID, "foo"),
386 ec_node_option(EC_NO_ID,
387 ec_node_str(EC_NO_ID, "toto")
389 ec_node_str(EC_NO_ID, "bar")
393 EC_LOG(EC_LOG_ERR, "cannot create node\n");
396 testres |= EC_TEST_CHECK_PARSE(node, 1, "foo bar");
397 testres |= EC_TEST_CHECK_PARSE(node, 1, " foo bar");
398 testres |= EC_TEST_CHECK_PARSE(node, 1, " 'foo' \"bar\"");
399 testres |= EC_TEST_CHECK_PARSE(node, 1, " 'f'oo 'toto' bar");
400 testres |= EC_TEST_CHECK_PARSE(node, -1, " foo toto bar'");
403 /* test completion */
404 node = ec_node_sh_lex(EC_NO_ID,
405 EC_NODE_SEQ(EC_NO_ID,
406 ec_node_str(EC_NO_ID, "foo"),
407 ec_node_option(EC_NO_ID,
408 ec_node_str(EC_NO_ID, "toto")
410 ec_node_str(EC_NO_ID, "bar"),
411 ec_node_str(EC_NO_ID, "titi")
415 EC_LOG(EC_LOG_ERR, "cannot create node\n");
418 testres |= EC_TEST_CHECK_COMPLETE(node,
420 "foo", EC_NODE_ENDLIST);
421 testres |= EC_TEST_CHECK_COMPLETE(node,
422 " ", EC_NODE_ENDLIST,
423 "foo", EC_NODE_ENDLIST);
424 testres |= EC_TEST_CHECK_COMPLETE(node,
425 "f", EC_NODE_ENDLIST,
426 "foo", EC_NODE_ENDLIST);
427 testres |= EC_TEST_CHECK_COMPLETE(node,
428 "foo", EC_NODE_ENDLIST,
429 "foo", EC_NODE_ENDLIST);
430 testres |= EC_TEST_CHECK_COMPLETE(node,
431 "foo ", EC_NODE_ENDLIST,
432 "bar", "toto", EC_NODE_ENDLIST);
433 testres |= EC_TEST_CHECK_COMPLETE(node,
434 "foo t", EC_NODE_ENDLIST,
435 "toto", EC_NODE_ENDLIST);
436 testres |= EC_TEST_CHECK_COMPLETE(node,
437 "foo b", EC_NODE_ENDLIST,
438 "bar", EC_NODE_ENDLIST);
439 testres |= EC_TEST_CHECK_COMPLETE(node,
440 "foo bar", EC_NODE_ENDLIST,
441 "bar", EC_NODE_ENDLIST);
442 testres |= EC_TEST_CHECK_COMPLETE(node,
443 "foo bar ", EC_NODE_ENDLIST,
444 "titi", EC_NODE_ENDLIST);
445 testres |= EC_TEST_CHECK_COMPLETE(node,
446 "foo toto bar ", EC_NODE_ENDLIST,
447 "titi", EC_NODE_ENDLIST);
448 testres |= EC_TEST_CHECK_COMPLETE(node,
449 "x", EC_NODE_ENDLIST,
451 testres |= EC_TEST_CHECK_COMPLETE(node,
452 "foo barx", EC_NODE_ENDLIST,
454 testres |= EC_TEST_CHECK_COMPLETE(node,
455 "foo 'b", EC_NODE_ENDLIST,
456 "'bar'", EC_NODE_ENDLIST);
463 static struct ec_test ec_node_sh_lex_test = {
464 .name = "node_sh_lex",
465 .test = ec_node_sh_lex_testcase,
468 EC_TEST_REGISTER(ec_node_sh_lex_test);