app/test-cmdline/commands.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <termios.h>
   8 #include <inttypes.h>
   9
  10 #include <rte_common.h>
  11
  12 #include <cmdline_rdline.h>
  13 #include <cmdline_parse.h>
  14 #include <cmdline_parse_string.h>
  15 #include <cmdline_parse_num.h>
  16 #include <cmdline.h>
  17
  18 #include "cmdline_test.h"
  19
  20 /*** quit ***/
  21 /* exit application */
  22
  23 struct cmd_quit_result {
  24         cmdline_fixed_string_t quit;
  25 };
  26
  27 static void
  28 cmd_quit_parsed(__rte_unused void *parsed_result,
  29                 struct cmdline *cl,
  30                 __rte_unused void *data)
  31 {
  32         cmdline_quit(cl);
  33 }
  34
  35 cmdline_parse_token_string_t cmd_quit_tok =
  36         TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit,
  37                                  "quit");
  38
  39 cmdline_parse_inst_t cmd_quit = {
  40         .f = cmd_quit_parsed,  /* function to call */
  41         .data = NULL,      /* 2nd arg of func */
  42         .help_str = "exit application",
  43         .tokens = {        /* token list, NULL terminated */
  44                 (void *)&cmd_quit_tok,
  45                 NULL,
  46         },
  47 };
  48
  49
  50
  51 /*** single ***/
  52 /* a simple single-word command */
  53
  54 struct cmd_single_result {
  55         cmdline_fixed_string_t single;
  56 };
  57
  58 static void
  59 cmd_single_parsed(__rte_unused void *parsed_result,
  60                 struct cmdline *cl,
  61                 __rte_unused void *data)
  62 {
  63         cmdline_printf(cl, "Single word command parsed!\n");
  64 }
  65
  66 cmdline_parse_token_string_t cmd_single_tok =
  67         TOKEN_STRING_INITIALIZER(struct cmd_single_result, single,
  68                                  "single");
  69
  70 cmdline_parse_inst_t cmd_single = {
  71         .f = cmd_single_parsed,  /* function to call */
  72         .data = NULL,      /* 2nd arg of func */
  73         .help_str = "a simple single-word command",
  74         .tokens = {        /* token list, NULL terminated */
  75                 (void *)&cmd_single_tok,
  76                 NULL,
  77         },
  78 };
  79
  80
  81
  82 /*** single_long ***/
  83 /* a variant of "single" command. useful to test autocomplete */
  84
  85 struct cmd_single_long_result {
  86         cmdline_fixed_string_t single_long;
  87 };
  88
  89 static void
  90 cmd_single_long_parsed(__rte_unused void *parsed_result,
  91                 struct cmdline *cl,
  92                 __rte_unused void *data)
  93 {
  94         cmdline_printf(cl, "Single long word command parsed!\n");
  95 }
  96
  97 cmdline_parse_token_string_t cmd_single_long_tok =
  98         TOKEN_STRING_INITIALIZER(struct cmd_single_long_result, single_long,
  99                                  "single_long");
 100
 101 cmdline_parse_inst_t cmd_single_long = {
 102         .f = cmd_single_long_parsed,  /* function to call */
 103         .data = NULL,      /* 2nd arg of func */
 104         .help_str = "a variant of \"single\" command, useful to test autocomplete",
 105         .tokens = {        /* token list, NULL terminated */
 106                 (void *)&cmd_single_long_tok,
 107                 NULL,
 108         },
 109 };
 110
 111
 112
 113 /*** autocomplete_1 ***/
 114 /* first command to test autocomplete when multiple commands have chars
 115  * in common but none should complete due to ambiguity
 116  */
 117
 118 struct cmd_autocomplete_1_result {
 119         cmdline_fixed_string_t token;
 120 };
 121
 122 static void
 123 cmd_autocomplete_1_parsed(__rte_unused void *parsed_result,
 124                 struct cmdline *cl,
 125                 __rte_unused void *data)
 126 {
 127         cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
 128 }
 129
 130 cmdline_parse_token_string_t cmd_autocomplete_1_tok =
 131         TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_1_result, token,
 132                                  "autocomplete_1");
 133
 134 cmdline_parse_inst_t cmd_autocomplete_1 = {
 135         .f = cmd_autocomplete_1_parsed,  /* function to call */
 136         .data = NULL,      /* 2nd arg of func */
 137         .help_str = "first ambiguous autocomplete command",
 138         .tokens = {        /* token list, NULL terminated */
 139                 (void *)&cmd_autocomplete_1_tok,
 140                 NULL,
 141         },
 142 };
 143
 144
 145
 146 /*** autocomplete_2 ***/
 147 /* second command to test autocomplete when multiple commands have chars
 148  * in common but none should complete due to ambiguity
 149  */
 150
 151 struct cmd_autocomplete_2_result {
 152         cmdline_fixed_string_t token;
 153 };
 154
 155 static void
 156 cmd_autocomplete_2_parsed(__rte_unused void *parsed_result,
 157                 struct cmdline *cl,
 158                 __rte_unused void *data)
 159 {
 160         cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
 161 }
 162
 163 cmdline_parse_token_string_t cmd_autocomplete_2_tok =
 164         TOKEN_STRING_INITIALIZER(struct cmd_autocomplete_2_result, token,
 165                                  "autocomplete_2");
 166
 167 cmdline_parse_inst_t cmd_autocomplete_2 = {
 168         .f = cmd_autocomplete_2_parsed,  /* function to call */
 169         .data = NULL,      /* 2nd arg of func */
 170         .help_str = "second ambiguous autocomplete command",
 171         .tokens = {        /* token list, NULL terminated */
 172                 (void *)&cmd_autocomplete_2_tok,
 173                 NULL,
 174         },
 175 };
 176
 177
 178
 179 /*** number command ***/
 180 /* a command that simply returns whatever (uint32) number is supplied to it */
 181
 182 struct cmd_num_result {
 183         unsigned num;
 184 };
 185
 186 static void
 187 cmd_num_parsed(void *parsed_result,
 188                 struct cmdline *cl,
 189                 __rte_unused void *data)
 190 {
 191         unsigned result = ((struct cmd_num_result*)parsed_result)->num;
 192         cmdline_printf(cl, "%u\n", result);
 193 }
 194
 195 cmdline_parse_token_num_t cmd_num_tok =
 196         TOKEN_NUM_INITIALIZER(struct cmd_num_result, num, RTE_UINT32);
 197
 198 cmdline_parse_inst_t cmd_num = {
 199         .f = cmd_num_parsed,  /* function to call */
 200         .data = NULL,      /* 2nd arg of func */
 201         .help_str = "a command that simply returns whatever number is entered",
 202         .tokens = {        /* token list, NULL terminated */
 203                 (void *)&cmd_num_tok,
 204                 NULL,
 205         },
 206 };
 207
 208
 209
 210 /*** ambiguous first|ambiguous ***/
 211 /* first command used to test command ambiguity */
 212
 213 struct cmd_ambig_result_1 {
 214         cmdline_fixed_string_t common_part;
 215         cmdline_fixed_string_t ambig_part;
 216 };
 217
 218 static void
 219 cmd_ambig_1_parsed(__rte_unused void *parsed_result,
 220                 struct cmdline *cl,
 221                 __rte_unused void *data)
 222 {
 223         cmdline_printf(cl, "Command 1 parsed!\n");
 224 }
 225
 226 cmdline_parse_token_string_t cmd_ambig_common_1 =
 227         TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, common_part,
 228                                  "ambiguous");
 229 cmdline_parse_token_string_t cmd_ambig_ambig_1 =
 230         TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_1, ambig_part,
 231                                  "first#ambiguous#ambiguous2");
 232
 233 cmdline_parse_inst_t cmd_ambig_1 = {
 234         .f = cmd_ambig_1_parsed,  /* function to call */
 235         .data = NULL,      /* 2nd arg of func */
 236         .help_str = "first command used to test command ambiguity",
 237         .tokens = {        /* token list, NULL terminated */
 238                 (void *)&cmd_ambig_common_1,
 239                 (void*)&cmd_ambig_ambig_1,
 240                 NULL,
 241         },
 242 };
 243
 244
 245
 246 /*** ambiguous second|ambiguous ***/
 247 /* second command used to test command ambiguity */
 248
 249 struct cmd_ambig_result_2 {
 250         cmdline_fixed_string_t common_part;
 251         cmdline_fixed_string_t ambig_part;
 252 };
 253
 254 static void
 255 cmd_ambig_2_parsed(__rte_unused void *parsed_result,
 256                 struct cmdline *cl,
 257                 __rte_unused void *data)
 258 {
 259         cmdline_printf(cl, "Command 2 parsed!\n");
 260 }
 261
 262 cmdline_parse_token_string_t cmd_ambig_common_2 =
 263         TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, common_part,
 264                                  "ambiguous");
 265 cmdline_parse_token_string_t cmd_ambig_ambig_2 =
 266         TOKEN_STRING_INITIALIZER(struct cmd_ambig_result_2, ambig_part,
 267                                  "second#ambiguous#ambiguous2");
 268
 269 cmdline_parse_inst_t cmd_ambig_2 = {
 270         .f = cmd_ambig_2_parsed,  /* function to call */
 271         .data = NULL,      /* 2nd arg of func */
 272         .help_str = "second command used to test command ambiguity",
 273         .tokens = {        /* token list, NULL terminated */
 274                 (void *)&cmd_ambig_common_2,
 275                 (void*)&cmd_ambig_ambig_2,
 276                 NULL,
 277         },
 278 };
 279
 280
 281
 282 /*** get_history_bufsize ***/
 283 /* command that displays total space in history buffer
 284  * this will be useful for testing history (to fill it up just enough to
 285  * remove the last entry, we need to know how big it is).
 286  */
 287
 288 struct cmd_get_history_bufsize_result {
 289         cmdline_fixed_string_t str;
 290 };
 291
 292 static void
 293 cmd_get_history_bufsize_parsed(__rte_unused void *parsed_result,
 294                 struct cmdline *cl,
 295                 __rte_unused void *data)
 296 {
 297         struct rdline *rdl = cmdline_get_rdline(cl);
 298
 299         cmdline_printf(cl, "History buffer size: %zu\n",
 300                         sizeof(rdl->history_buf));
 301 }
 302
 303 cmdline_parse_token_string_t cmd_get_history_bufsize_tok =
 304         TOKEN_STRING_INITIALIZER(struct cmd_get_history_bufsize_result, str,
 305                                  "get_history_bufsize");
 306
 307 cmdline_parse_inst_t cmd_get_history_bufsize = {
 308         .f = cmd_get_history_bufsize_parsed,  /* function to call */
 309         .data = NULL,      /* 2nd arg of func */
 310         .help_str = "command that displays total space in history buffer",
 311         .tokens = {        /* token list, NULL terminated */
 312                 (void *)&cmd_get_history_bufsize_tok,
 313                 NULL,
 314         },
 315 };
 316
 317
 318
 319 /*** clear_history ***/
 320 /* clears history buffer */
 321
 322 struct cmd_clear_history_result {
 323         cmdline_fixed_string_t str;
 324 };
 325
 326 static void
 327 cmd_clear_history_parsed(__rte_unused void *parsed_result,
 328                 struct cmdline *cl,
 329                 __rte_unused void *data)
 330 {
 331         struct rdline *rdl = cmdline_get_rdline(cl);
 332
 333         rdline_clear_history(rdl);
 334 }
 335
 336 cmdline_parse_token_string_t cmd_clear_history_tok =
 337         TOKEN_STRING_INITIALIZER(struct cmd_clear_history_result, str,
 338                                  "clear_history");
 339
 340 cmdline_parse_inst_t cmd_clear_history = {
 341         .f = cmd_clear_history_parsed,  /* function to call */
 342         .data = NULL,      /* 2nd arg of func */
 343         .help_str = "clear command history",
 344         .tokens = {        /* token list, NULL terminated */
 345                 (void *)&cmd_clear_history_tok,
 346                 NULL,
 347         },
 348 };
 349
 350
 351
 352 /****************/
 353
 354 cmdline_parse_ctx_t main_ctx[] = {
 355                 (cmdline_parse_inst_t *)&cmd_quit,
 356                 (cmdline_parse_inst_t *)&cmd_ambig_1,
 357                 (cmdline_parse_inst_t *)&cmd_ambig_2,
 358                 (cmdline_parse_inst_t *)&cmd_single,
 359                 (cmdline_parse_inst_t *)&cmd_single_long,
 360                 (cmdline_parse_inst_t *)&cmd_num,
 361                 (cmdline_parse_inst_t *)&cmd_get_history_bufsize,
 362                 (cmdline_parse_inst_t *)&cmd_clear_history,
 363                 (cmdline_parse_inst_t *)&cmd_autocomplete_1,
 364                 (cmdline_parse_inst_t *)&cmd_autocomplete_2,
 365         NULL,
 366 };