Branch data Line data Source code
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 : 0 : cmd_quit_parsed(__rte_unused void *parsed_result,
29 : : struct cmdline *cl,
30 : : __rte_unused void *data)
31 : : {
32 : 0 : cmdline_quit(cl);
33 : 0 : }
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 : 0 : cmd_single_parsed(__rte_unused void *parsed_result,
60 : : struct cmdline *cl,
61 : : __rte_unused void *data)
62 : : {
63 : 0 : cmdline_printf(cl, "Single word command parsed!\n");
64 : 0 : }
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 : 0 : cmd_single_long_parsed(__rte_unused void *parsed_result,
91 : : struct cmdline *cl,
92 : : __rte_unused void *data)
93 : : {
94 : 0 : cmdline_printf(cl, "Single long word command parsed!\n");
95 : 0 : }
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 : 0 : cmd_autocomplete_1_parsed(__rte_unused void *parsed_result,
124 : : struct cmdline *cl,
125 : : __rte_unused void *data)
126 : : {
127 : 0 : cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
128 : 0 : }
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 : 0 : cmd_autocomplete_2_parsed(__rte_unused void *parsed_result,
157 : : struct cmdline *cl,
158 : : __rte_unused void *data)
159 : : {
160 : 0 : cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
161 : 0 : }
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 : 0 : cmd_num_parsed(void *parsed_result,
188 : : struct cmdline *cl,
189 : : __rte_unused void *data)
190 : : {
191 : 0 : unsigned result = ((struct cmd_num_result*)parsed_result)->num;
192 : 0 : cmdline_printf(cl, "%u\n", result);
193 : 0 : }
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 : 0 : cmd_ambig_1_parsed(__rte_unused void *parsed_result,
220 : : struct cmdline *cl,
221 : : __rte_unused void *data)
222 : : {
223 : 0 : cmdline_printf(cl, "Command 1 parsed!\n");
224 : 0 : }
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 : 0 : cmd_ambig_2_parsed(__rte_unused void *parsed_result,
256 : : struct cmdline *cl,
257 : : __rte_unused void *data)
258 : : {
259 : 0 : cmdline_printf(cl, "Command 2 parsed!\n");
260 : 0 : }
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 : 0 : cmd_get_history_bufsize_parsed(__rte_unused void *parsed_result,
294 : : struct cmdline *cl,
295 : : __rte_unused void *data)
296 : : {
297 : 0 : struct rdline *rdl = cmdline_get_rdline(cl);
298 : :
299 : 0 : cmdline_printf(cl, "History buffer size: %zu\n",
300 : : rdline_get_history_buffer_size(rdl));
301 : 0 : }
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 : 0 : cmd_clear_history_parsed(__rte_unused void *parsed_result,
328 : : struct cmdline *cl,
329 : : __rte_unused void *data)
330 : : {
331 : 0 : struct rdline *rdl = cmdline_get_rdline(cl);
332 : :
333 : 0 : rdline_clear_history(rdl);
334 : 0 : }
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 : : };
|
