cmdline: support dynamic tokens

Considering tokens must be hard-coded in a list part of the instruction
structure, context-dependent tokens cannot be expressed.

This commit adds support for building dynamic token lists through a
user-provided function, which is called when the static token list is empty
(a single NULL entry).

Because no structures are modified (existing fields are reused), this
commit has no impact on the current ABI.

Signed-off-by: Adrien Mazarguil <adrien.mazarguil@6wind.com>
Acked-by: Olga Shern <olgas@mellanox.com>

diff --git a/lib/librte_cmdline/cmdline_parse.c b/lib/librte_cmdline/cmdline_parse.c
index b496067aa77e9eb22801c984a920cea31a6fdddc..14f555378c25cd454b926e34450b8bec19972e01 100644 (file)
--- a/lib/librte_cmdline/cmdline_parse.c
+++ b/lib/librte_cmdline/cmdline_parse.c
@@ -146,7 +146,9 @@ nb_common_chars(const char * s1, const char * s2)
  */
 static int
 match_inst(cmdline_parse_inst_t *inst, const char *buf,
-          unsigned int nb_match_token, void *resbuf, unsigned resbuf_size)
+          unsigned int nb_match_token, void *resbuf, unsigned resbuf_size,
+          cmdline_parse_token_hdr_t
+               *(*dyn_tokens)[CMDLINE_PARSE_DYNAMIC_TOKENS])
 {
        unsigned int token_num=0;
        cmdline_parse_token_hdr_t * token_p;
@@ -155,6 +157,11 @@ match_inst(cmdline_parse_inst_t *inst, const char *buf,
        struct cmdline_token_hdr token_hdr;
 
        token_p = inst->tokens[token_num];
+       if (!token_p && dyn_tokens && inst->f) {
+               if (!(*dyn_tokens)[0])
+                       inst->f(&(*dyn_tokens)[0], NULL, dyn_tokens);
+               token_p = (*dyn_tokens)[0];
+       }
        if (token_p)
                memcpy(&token_hdr, token_p, sizeof(token_hdr));
 
@@ -196,7 +203,17 @@ match_inst(cmdline_parse_inst_t *inst, const char *buf,
                buf += n;
 
                token_num ++;
-               token_p = inst->tokens[token_num];
+               if (!inst->tokens[0]) {
+                       if (token_num < (CMDLINE_PARSE_DYNAMIC_TOKENS - 1)) {
+                               if (!(*dyn_tokens)[token_num])
+                                       inst->f(&(*dyn_tokens)[token_num],
+                                               NULL,
+                                               dyn_tokens);
+                               token_p = (*dyn_tokens)[token_num];
+                       } else
+                               token_p = NULL;
+               } else
+                       token_p = inst->tokens[token_num];
                if (token_p)
                        memcpy(&token_hdr, token_p, sizeof(token_hdr));
        }
@@ -239,6 +256,7 @@ cmdline_parse(struct cmdline *cl, const char * buf)
        cmdline_parse_inst_t *inst;
        const char *curbuf;
        char result_buf[CMDLINE_PARSE_RESULT_BUFSIZE];
+       cmdline_parse_token_hdr_t *dyn_tokens[CMDLINE_PARSE_DYNAMIC_TOKENS];
        void (*f)(void *, struct cmdline *, void *) = NULL;
        void *data = NULL;
        int comment = 0;
@@ -255,6 +273,7 @@ cmdline_parse(struct cmdline *cl, const char * buf)
                return CMDLINE_PARSE_BAD_ARGS;
 
        ctx = cl->ctx;
+       memset(&dyn_tokens, 0, sizeof(dyn_tokens));
 
        /*
         * - look if the buffer contains at least one line
@@ -299,7 +318,8 @@ cmdline_parse(struct cmdline *cl, const char * buf)
                debug_printf("INST %d\n", inst_num);
 
                /* fully parsed */
-               tok = match_inst(inst, buf, 0, result_buf, sizeof(result_buf));
+               tok = match_inst(inst, buf, 0, result_buf, sizeof(result_buf),
+                                &dyn_tokens);
 
                if (tok > 0) /* we matched at least one token */
                        err = CMDLINE_PARSE_BAD_ARGS;
@@ -355,6 +375,7 @@ cmdline_complete(struct cmdline *cl, const char *buf, int *state,
        cmdline_parse_token_hdr_t *token_p;
        struct cmdline_token_hdr token_hdr;
        char tmpbuf[CMDLINE_BUFFER_SIZE], comp_buf[CMDLINE_BUFFER_SIZE];
+       cmdline_parse_token_hdr_t *dyn_tokens[CMDLINE_PARSE_DYNAMIC_TOKENS];
        unsigned int partial_tok_len;
        int comp_len = -1;
        int tmp_len = -1;
@@ -374,6 +395,7 @@ cmdline_complete(struct cmdline *cl, const char *buf, int *state,
 
        debug_printf("%s called\n", __func__);
        memset(&token_hdr, 0, sizeof(token_hdr));
+       memset(&dyn_tokens, 0, sizeof(dyn_tokens));
 
        /* count the number of complete token to parse */
        for (i=0 ; buf[i] ; i++) {
@@ -396,11 +418,24 @@ cmdline_complete(struct cmdline *cl, const char *buf, int *state,
                inst = ctx[inst_num];
                while (inst) {
                        /* parse the first tokens of the inst */
-                       if (nb_token && match_inst(inst, buf, nb_token, NULL, 0))
+                       if (nb_token &&
+                           match_inst(inst, buf, nb_token, NULL, 0,
+                                      &dyn_tokens))
                                goto next;
 
                        debug_printf("instruction match\n");
-                       token_p = inst->tokens[nb_token];
+                       if (!inst->tokens[0]) {
+                               if (nb_token <
+                                   (CMDLINE_PARSE_DYNAMIC_TOKENS - 1)) {
+                                       if (!dyn_tokens[nb_token])
+                                               inst->f(&dyn_tokens[nb_token],
+                                                       NULL,
+                                                       &dyn_tokens);
+                                       token_p = dyn_tokens[nb_token];
+                               } else
+                                       token_p = NULL;
+                       } else
+                               token_p = inst->tokens[nb_token];
                        if (token_p)
                                memcpy(&token_hdr, token_p, sizeof(token_hdr));
 
@@ -490,10 +525,21 @@ cmdline_complete(struct cmdline *cl, const char *buf, int *state,
                /* we need to redo it */
                inst = ctx[inst_num];
 
-               if (nb_token && match_inst(inst, buf, nb_token, NULL, 0))
+               if (nb_token &&
+                   match_inst(inst, buf, nb_token, NULL, 0, &dyn_tokens))
                        goto next2;
 
-               token_p = inst->tokens[nb_token];
+               if (!inst->tokens[0]) {
+                       if (nb_token < (CMDLINE_PARSE_DYNAMIC_TOKENS - 1)) {
+                               if (!dyn_tokens[nb_token])
+                                       inst->f(&dyn_tokens[nb_token],
+                                               NULL,
+                                               &dyn_tokens);
+                               token_p = dyn_tokens[nb_token];
+                       } else
+                               token_p = NULL;
+               } else
+                       token_p = inst->tokens[nb_token];
                if (token_p)
                        memcpy(&token_hdr, token_p, sizeof(token_hdr));
 

diff --git a/lib/librte_cmdline/cmdline_parse.h b/lib/librte_cmdline/cmdline_parse.h
index 4ac05d6b8964ad09bc7a161d7e578ab7a62c893e..65b18d4f6ba8902324e0ced8f2aa7d32b4cbf441 100644 (file)
--- a/lib/librte_cmdline/cmdline_parse.h
+++ b/lib/librte_cmdline/cmdline_parse.h
@@ -83,6 +83,9 @@ extern "C" {
 /* maximum buffer size for parsed result */
 #define CMDLINE_PARSE_RESULT_BUFSIZE 8192
 
+/* maximum number of dynamic tokens */
+#define CMDLINE_PARSE_DYNAMIC_TOKENS 128
+
 /**
  * Stores a pointer to the ops struct, and the offset: the place to
  * write the parsed result in the destination structure.
@@ -130,6 +133,24 @@ struct cmdline;
  * Store a instruction, which is a pointer to a callback function and
  * its parameter that is called when the instruction is parsed, a help
  * string, and a list of token composing this instruction.
+ *
+ * When no tokens are defined (tokens[0] == NULL), they are retrieved
+ * dynamically by calling f() as follows:
+ *
+ *  f((struct cmdline_token_hdr **)&token_hdr,
+ *    NULL,
+ *    (struct cmdline_token_hdr *[])tokens));
+ *
+ * The address of the resulting token is expected at the location pointed by
+ * the first argument. Can be set to NULL to end the list.
+ *
+ * The cmdline argument (struct cmdline *) is always NULL.
+ *
+ * The last argument points to the NULL-terminated list of dynamic tokens
+ * defined so far. Since token_hdr points to an index of that list, the
+ * current index can be derived as follows:
+ *
+ *  int index = token_hdr - &(*tokens)[0];
  */
 struct cmdline_inst {
        /* f(parsed_struct, data) */