4 * This file is part of BeRTOS.
6 * Bertos is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 * As a special exception, you may use this file as part of a free software
21 * library without restriction. Specifically, if other files instantiate
22 * templates or use macros or inline functions from this file, or you compile
23 * this file and link it with other files to produce an executable, this
24 * file does not by itself cause the resulting executable to be covered by
25 * the GNU General Public License. This exception does not however
26 * invalidate any other reasons why the executable file might be covered by
27 * the GNU General Public License.
29 * Copyright 2003, 2006 Develer S.r.l. (http://www.develer.com/)
30 * All Rights Reserved.
33 * \brief Channel protocol parser and commands.
35 * This file contains the channel protocol parser and
36 * the definition of the protocol commands. Commands are defined
37 * in a "CmdTemplate" type array, containing:
38 * - the name of the command,
39 * - the arguments it expects to receive,
40 * - the output values,
41 * - the name of the function implementing the command.
43 * The arguments and results are passed to command function
44 * using an union: the element of the union to use for each
45 * argument is determined by format strings present in the
48 * \author Bernie Innocenti <bernie@codewiz.org>
49 * \author Stefano Fedrigo <aleph@develer.com>
50 * \author Giovanni Bajo <rasky@develer.com>
59 #include <struct/hashtable.h>
61 #include <stdlib.h> // atol(), NULL
62 #include <string.h> // strchr(), strcmp()
64 /// Hashtable hook to extract the key from a command
65 static const void* get_key_from_command(const void* cmd, uint8_t* length);
67 /// Hashtable that handles the commands that can be executed
68 DECLARE_HASHTABLE_STATIC(commands, CONFIG_MAX_COMMANDS_NUMBER, get_key_from_command);
72 * \brief Tokenize one word at a time from a text.
74 * This function is similar to strtok, but does not use any implicit
75 * context, nor it does modify the input buffer in any form.
76 * The word is returned as a STL-like [begin,end) range.
78 * To extract the first word, make both begin and end point at the
79 * start of the text, and call the function. Then, subsequent
80 * calls will return the following words (assuming the begin/end
81 * variable are not modified between calls).
83 * \param begin Will contain the index of the first character of the word
84 * \param end Will contain the index of the character after the last
85 * character of the word
87 * \return True if a word was extracted, false if we got to the end
88 * of the string without extracting any word.
90 static bool get_word(const char **begin, const char **end)
92 const char *cur = *end;
94 while ((*cur == ' ' || *cur == '\t') && *cur)
99 while ((*cur != ' ' && *cur != '\t') && *cur)
104 return (*end != *begin);
109 * \brief Command arguments parser.
111 * Using the format pointed by the argument fmt
112 * parses the input string filling the array argv
113 * with input parameters of the correct type.
115 * \param fmt Parameters format string.
116 * \param input Input string.
117 * \param argv Array filled with parameters.
119 * \return False in case of errors, otherwise true.
121 static bool parseArgs(const char *fmt, const char *input, parms argv[])
123 const char *begin = input, *end = input;
127 // Extract the argument
128 if (!get_word(&begin, &end))
134 (*argv++).l = atol(begin);
142 ASSERT2(0, "Unknown format for argument");
149 /* check if there are remaining args */
150 if (get_word(&begin, &end))
156 /// Hook provided by the parser for matching of command names (TAB completion) for readline
157 const char* parser_rl_match(UNUSED_ARG(void *,dummy), const char *word, int word_len)
160 HashIterator end = ht_iter_end(&commands);
161 const char *found = NULL;
163 for (cur = ht_iter_begin(&commands);
164 !ht_iter_cmp(cur, end);
165 cur = ht_iter_next(cur))
167 const struct CmdTemplate* cmdp = (const struct CmdTemplate*)ht_iter_get(cur);
168 if (strncmp(cmdp->name, word, word_len) == 0)
170 // If there was another matching word, it means that we have a multiple
171 // match: then return NULL.
182 #if CONFIG_ENABLE_COMPAT_BEHAVIOUR
183 bool parser_get_cmd_id(const char* line, unsigned long* ID)
185 const char *begin = line, *end = line;
188 // The first word is the ID
189 if (!get_word(&begin, &end))
192 *ID = strtoul(begin, &end2, 10);
201 * Find the template for the command contained in the text line.
202 * The template can be used to tokenize the command and interpret
205 * This function can be used to find out which command is contained
206 * in a given text line without parsing all the parameters and
209 * \param input Text line to be processed (ASCIIZ)
211 * \return The command template associated with the command contained
212 * in the line, or NULL if the command is invalid.
214 const struct CmdTemplate* parser_get_cmd_template(const char *input)
216 const char *begin = input, *end = input;
218 #if CONFIG_ENABLE_COMPAT_BEHAVIOUR
219 // Skip the ID, and get the command
220 if (!get_word(&begin, &end))
223 if (!get_word(&begin, &end))
226 return (const struct CmdTemplate*)ht_find(&commands, begin, end-begin);
229 static const char *skip_to_params(const char *input, const struct CmdTemplate *cmdp)
231 const char *begin = input, *end = input;
233 #if CONFIG_ENABLE_COMPAT_BEHAVIOUR
234 // Skip the ID, and get the command
235 if (!get_word(&begin, &end))
238 if (!get_word(&begin, &end))
241 ASSERT2(strlen(cmdp->name) == (size_t)(end-begin), "Invalid command template specified");
242 ASSERT2(!strncmp(begin, cmdp->name, end-begin), "Invalid command template specified");
248 * Extract the arguments for the command contained in the text line.
250 * The first argument will always be the command name, so the actual arguments
251 * will start at index 1.
253 * \param input Text line to be processed (ASCIIZ)
254 * \param cmdp Command template for this line
255 * \param args Will contain the extracted parameters
257 * \return True if everything OK, false in case of parsing error.
259 bool parser_get_cmd_arguments(const char* input, const struct CmdTemplate* cmdp, parms args[CONFIG_PARSER_MAX_ARGS])
261 input = skip_to_params(input, cmdp);
265 args[0].s = cmdp->name;
266 if (!parseArgs(cmdp->arg_fmt, input, args + 1))
272 static const void* get_key_from_command(const void* cmd, uint8_t* length)
274 const struct CmdTemplate* c = cmd;
275 *length = strlen(c->name);
280 * \brief Command input handler.
282 * Process the input, calling the requested command (if found).
284 * \param input Text line to be processed (ASCIIZ)
286 * \return true if everything is OK, false in case of errors
288 bool parser_process_line(const char* input)
290 const struct CmdTemplate *cmdp;
291 parms args[CONFIG_PARSER_MAX_ARGS];
293 cmdp = parser_get_cmd_template(input);
297 if (!parser_get_cmd_arguments(input, cmdp, args))
300 if (!parser_execute_cmd(cmdp, args))
307 * Register a new command into the parser
309 * \param cmd Command template describing the command
311 void parser_register_cmd(const struct CmdTemplate* cmd)
313 ht_insert(&commands, cmd);
316 void parser_init(void)
318 // Initialize the hashtable used to store the command description