Fix the bug related to the version list.
[bertos.git] / bertos / mware / parser.c
1 /**
2  * \file
3  * <!--
4  * This file is part of BeRTOS.
5  *
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.
10  *
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.
15  *
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
19  *
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.
28  *
29  * Copyright 2003, 2006 Develer S.r.l. (http://www.develer.com/)
30  * All Rights Reserved.
31  * -->
32  *
33  * \brief Serial protocol parser and commands.
34  *
35  * This file contains the serial 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.
42  *
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
46  * CmdTemplate table.
47  *
48  * \version $Id$
49  *
50  * \author Bernie Innocenti <bernie@codewiz.org>
51  * \author Stefano Fedrigo <aleph@develer.com>
52  * \author Giovanni Bajo <rasky@develer.com>
53  *
54  *
55  */
56
57
58 #include "parser.h"
59
60 #include "cfg/cfg_parser.h"
61
62 #include <drv/ser.h>
63 #include <struct/hashtable.h>
64
65 #include <stdlib.h> // atol(), NULL
66 #include <string.h> // strchr(), strcmp()
67
68
69
70 #define ARG_SEP_S " "
71 #define ARG_SEP_C ' '
72
73 #define MAX_COMMANDS_NUMBER  128  // 64
74
75 /// Hashtable hook to extract the key from a command
76 static const void* get_key_from_command(const void* cmd, uint8_t* length);
77
78 /// Hashtable that handles the commands that can be executed
79 DECLARE_HASHTABLE_STATIC(commands, MAX_COMMANDS_NUMBER, get_key_from_command);
80
81
82 /**
83  * \brief Tokenize one word at a time from a text.
84  *
85  * This function is similar to strtok, but does not use any implicit
86  * context, nor it does modify the input buffer in any form.
87  * The word is returned as a STL-like [begin,end) range.
88  *
89  * To extract the first word, make both begin and end point at the
90  * start of the text, and call the function. Then, subsequent
91  * calls will return the following words (assuming the begin/end
92  * variable are not modified between calls).
93  *
94  * \param begin Will contain the index of the first character of the word
95  * \param end Will contain the index of the character after the last
96  *     character of the word
97  *
98  * \return True if a word was extracted, false if we got to the end
99  * of the string without extracting any word.
100  */
101 static bool get_word(const char **begin, const char **end)
102 {
103         const char *cur = *end;
104
105         while ((*cur == ' ' || *cur == '\t') && *cur)
106                 ++cur;
107
108         *begin = cur;
109
110         while ((*cur != ' ' && *cur != '\t') && *cur)
111                 ++cur;
112
113         *end = cur;
114
115         return (*end != *begin);
116 }
117
118
119 /**
120  * \brief Command arguments parser.
121  *
122  * Using the format pointed by the argument fmt
123  * parses the input string filling the array argv
124  * with input parameters of the correct type.
125  *
126  * \param fmt   Parameters format string.
127  * \param input Input string.
128  * \param argv  Array filled with parameters.
129  *
130  * \return False in case of errors, otherwise true.
131  */
132 static bool parseArgs(const char *fmt, const char *input, parms argv[])
133 {
134         const char *begin = input, *end = input;
135
136         while (*fmt)
137         {
138                 // Extract the argument
139                 if (!get_word(&begin, &end))
140                         return false;
141
142                 switch (*fmt)
143                 {
144                         case 'd':
145                                 (*argv++).l = atol(begin);
146                                 break;
147
148                         case 's':
149                                 (*argv++).s = begin;
150                                 break;
151
152                         default:
153                                 ASSERT2(0, "Unknown format for argument");
154                                 return false;
155                 }
156
157                 ++fmt;
158         }
159
160         /* check if there are remaining args */
161         if (get_word(&begin, &end))
162                 return false;
163
164         return true;
165 }
166
167
168 #ifdef UNUSED_CODE
169 /**
170  * \brief Command result formatting and printing.
171  *
172  * Prints out on device fd the values contained
173  * in the array result, using the format specified
174  * in fmt.
175  *
176  * \param ser     Serial handle.
177  * \param fmt     Values format string.
178  * \param result  Array containing result to be printed.
179  *
180  * \return -1 in case of errors, otherwise 0.
181  */
182 static int printResult(struct Serial *ser, const char *fmt, parms result[])
183 {
184         long n;
185         char repeat_cnt = 0;
186
187         while (*fmt)
188         {
189                 if (*fmt >= '0' && *fmt <= '9')
190                 {
191                         /* Collect repeat count digit (left to right order) */
192                         repeat_cnt = (repeat_cnt * 10) + (*fmt - '0');
193                 }
194                 else
195                 {
196                         /* Set default repeat cnt of 1 when not specified */
197                         if (repeat_cnt == 0)
198                                 repeat_cnt = 1;
199
200                         /* Loop repeat_cnt times */
201                         do
202                         {
203                                 switch (*fmt)
204                                 {
205                                         case 'd':
206                                                 ser_printf(ser, ARG_SEP_S "%ld", (*result).l);
207                                                 result++;
208                                                 break;
209                                         case 'c':
210                                                 ser_print(ser, ARG_SEP_S);
211                                                 ser_print(ser, (*result).s);
212                                                 result++;
213                                                 break;
214                                         case 's':
215                                                 ser_printf(ser, ARG_SEP_S "%s", (*result).s);
216                                                 result++;
217                                                 break;
218                                         case 'n':
219                                                 n = (*result++).l;
220                                                 ser_printf(ser, ARG_SEP_S "%ld", n);
221                                                 while (n--) {
222                                                         ser_printf(ser, ARG_SEP_S "%ld", (*result).l);
223                                                         result++;
224                                                 }
225                                                 break;
226                                         default:
227                                                 break;
228                                 }
229                         }
230                         while (--repeat_cnt);
231                 }
232
233                 /* Skip to next format char */
234                 ++fmt;
235
236         } /* while (*fmt) */
237
238
239         ser_print(ser, "\r\n");
240         return 0;
241 }
242 #endif /* UNUSED_CODE */
243
244 /// Hook provided by the parser for matching of command names (TAB completion) for readline
245 const char* parser_rl_match(UNUSED_ARG(void *,dummy), const char *word, int word_len)
246 {
247         HashIterator cur;
248         HashIterator end = ht_iter_end(&commands);
249         const char *found = NULL;
250
251         for (cur = ht_iter_begin(&commands);
252              !ht_iter_cmp(cur, end);
253              cur = ht_iter_next(cur))
254         {
255                 const struct CmdTemplate* cmdp = (const struct CmdTemplate*)ht_iter_get(cur);
256                 if (strncmp(cmdp->name, word, word_len) == 0)
257                 {
258                         // If there was another matching word, it means that we have a multiple
259                         //  match: then return NULL.
260                         if (found)
261                                 return NULL;
262
263                         found = cmdp->name;
264                 }
265         }
266
267         return found;
268 }
269
270 bool parser_get_cmd_id(const char* line, unsigned long* ID)
271 {
272         const char *begin = line, *end = line;
273         char *end2;
274
275         // The first word is the ID
276         if (!get_word(&begin, &end))
277                 return false;
278
279         *ID = strtoul(begin, &end2, 10);
280         if (end2 != end)
281                 return false;
282
283         return true;
284 }
285
286 const struct CmdTemplate* parser_get_cmd_template(const char *input)
287 {
288 //      const struct CmdTemplate *cmdp;
289 //      int cmdlen;
290         const char *begin = input, *end = input;
291
292         // Skip the ID, and get the command
293         if (!get_word(&begin, &end))
294                 return NULL;
295         if (!get_word(&begin, &end))
296                 return NULL;
297
298         return (const struct CmdTemplate*)ht_find(&commands, begin, end-begin);
299 }
300
301 static const char *skip_to_params(const char *input, const struct CmdTemplate *cmdp)
302 {
303         const char *begin = input, *end = input;
304
305         // Skip the ID, and get the command
306         if (!get_word(&begin, &end))
307                 return NULL;
308         if (!get_word(&begin, &end))
309                 return NULL;
310
311         ASSERT2(strlen(cmdp->name) == (size_t)(end-begin), "Invalid command template specified");
312         ASSERT2(!strncmp(begin, cmdp->name, end-begin), "Invalid command template specified");
313
314         return end;
315 }
316
317 bool parser_get_cmd_arguments(const char* input, const struct CmdTemplate* cmdp, parms args[PARSER_MAX_ARGS])
318 {
319         input = skip_to_params(input, cmdp);
320         if (!input)
321                 return false;
322
323         args[0].s = cmdp->name;
324         if (!parseArgs(cmdp->arg_fmt, input, args + 1))
325                 return false;
326
327         return true;
328 }
329
330 static const void* get_key_from_command(const void* cmd, uint8_t* length)
331 {
332         const struct CmdTemplate* c = cmd;
333         *length = strlen(c->name);
334         return c->name;
335 }
336
337 bool parser_process_line(const char* input)
338 {
339         const struct CmdTemplate *cmdp;
340         parms args[PARSER_MAX_ARGS];
341
342         cmdp = parser_get_cmd_template(input);
343         if (!cmdp)
344                 return false;
345
346         if (!parser_get_cmd_arguments(input, cmdp, args))
347                 return false;
348
349         if (!parser_execute_cmd(cmdp, args))
350                 return false;
351
352         return true;
353 }
354
355 void parser_register_cmd(const struct CmdTemplate* cmd)
356 {
357         ht_insert(&commands, cmd);
358 }
359
360 #if CONFIG_INTERNAL_COMMANDS
361 #warning FIXME:This code use boost lib, if you compile with internal command you must fix it.
362 static ResultCode cmd_help(void)
363 {
364 #ifdef _DEBUG
365
366         // FIXME: There is no way at the moment to access the serial port. Dump
367         //  this through JTAG for now
368         for (HashIterator iter = ht_iter_begin(&commands);
369                 !ht_iter_cmp(iter, ht_iter_end(&commands));
370                 iter = ht_iter_next(iter))
371         {
372                 struct CmdTemplate* cmd = (struct CmdTemplate*)ht_iter_get(iter);
373                 kprintf("%-20s", cmd->name);
374                 for (unsigned j = 0; cmd->arg_fmt[j]; ++j)
375                         kprintf("%c ", 'a' + j);
376                 kprintf("\r\n");
377         }
378 #endif
379
380         return RC_OK;
381 }
382
383 #include "cmd_hunk.h"
384 DECLARE_CMD_HUNK(help, (NIL), (NIL));
385
386 #endif // CONFIG_INTERNAL_COMMANDS
387
388
389 void parser_init(void)
390 {
391         // Initialize the hashtable used to store the command description
392         ht_init(&commands);
393
394 #if CONFIG_INTERNAL_COMMANDS
395         parser_register_cmd(&CMD_HUNK_TEMPLATE(help));
396 #endif
397 }