.cfg files are now executed as Jim Tcl. Commands that terminate script w/error message.
[openocd.git] / src / helper / command.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * part of this file is taken from libcli (libcli.sourceforge.net) *
6 * Copyright (C) David Parrish (david@dparrish.com) *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "replacements.h"
28
29 #include "command.h"
30
31 #include "log.h"
32 #include "time_support.h"
33
34 #include <stdlib.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <unistd.h>
40
41 int fast_and_dangerous = 0;
42
43 void command_print_help_line(command_context_t* context, struct command_s *command, int indent);
44
45 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48
49 /* forward declaration of jim_command */
50 extern int jim_command(command_context_t *context, char *line);
51
52 int build_unique_lengths(command_context_t *context, command_t *commands)
53 {
54 command_t *c, *p;
55
56 /* iterate through all commands */
57 for (c = commands; c; c = c->next)
58 {
59 /* find out how many characters are required to uniquely identify a command */
60 for (c->unique_len = 1; c->unique_len <= strlen(c->name); c->unique_len++)
61 {
62 int foundmatch = 0;
63
64 /* for every command, see if the current length is enough */
65 for (p = commands; p; p = p->next)
66 {
67 /* ignore the command itself */
68 if (c == p)
69 continue;
70
71 /* compare commands up to the current length */
72 if (strncmp(p->name, c->name, c->unique_len) == 0)
73 foundmatch++;
74 }
75
76 /* when none of the commands matched, we've found the minimum length required */
77 if (!foundmatch)
78 break;
79 }
80
81 /* if the current command has children, build the unique lengths for them */
82 if (c->children)
83 build_unique_lengths(context, c->children);
84 }
85
86 return ERROR_OK;
87 }
88
89 /* Avoid evaluating this each time we add a command. Reduces overhead from O(n^2) to O(n).
90 * Makes a difference on ARM7 types machines and is not observable on GHz machines.
91 */
92 static int unique_length_dirty = 1;
93
94 command_t* register_command(command_context_t *context, command_t *parent, char *name, int (*handler)(struct command_context_s *context, char* name, char** args, int argc), enum command_mode mode, char *help)
95 {
96 command_t *c, *p;
97 unique_length_dirty = 1;
98
99 if (!context || !name)
100 return NULL;
101
102 c = malloc(sizeof(command_t));
103
104 c->name = strdup(name);
105 c->parent = parent;
106 c->children = NULL;
107 c->handler = handler;
108 c->mode = mode;
109 if (help)
110 c->help = strdup(help);
111 else
112 c->help = NULL;
113 c->unique_len = 0;
114 c->next = NULL;
115
116 /* place command in tree */
117 if (parent)
118 {
119 if (parent->children)
120 {
121 /* find last child */
122 for (p = parent->children; p && p->next; p = p->next);
123 if (p)
124 p->next = c;
125 }
126 else
127 {
128 parent->children = c;
129 }
130 }
131 else
132 {
133 if (context->commands)
134 {
135 /* find last command */
136 for (p = context->commands; p && p->next; p = p->next);
137 if (p)
138 p->next = c;
139 }
140 else
141 {
142 context->commands = c;
143 }
144 }
145
146 return c;
147 }
148
149 int unregister_all_commands(command_context_t *context)
150 {
151 command_t *c, *c2;
152
153 unique_length_dirty = 1;
154
155 if (context == NULL)
156 return ERROR_OK;
157
158
159 while(NULL != context->commands)
160 {
161 c = context->commands;
162
163 while(NULL != c->children)
164 {
165 c2 = c->children;
166 c->children = c->children->next;
167 free(c2->name);
168 c2->name = NULL;
169 free(c2->help);
170 c2->help = NULL;
171 free(c2);
172 c2 = NULL;
173 }
174
175 context->commands = context->commands->next;
176
177 free(c->name);
178 c->name = NULL;
179 free(c->help);
180 c->help = NULL;
181 free(c);
182 c = NULL;
183 }
184
185 return ERROR_OK;
186 }
187
188 int unregister_command(command_context_t *context, char *name)
189 {
190 command_t *c, *p = NULL, *c2;
191
192 unique_length_dirty = 1;
193
194 if ((!context) || (!name))
195 return ERROR_INVALID_ARGUMENTS;
196
197 /* find command */
198 for (c = context->commands; c; c = c->next)
199 {
200 if (strcmp(name, c->name) == 0)
201 {
202 /* unlink command */
203 if (p)
204 {
205 p->next = c->next;
206 }
207 else
208 {
209 context->commands = c->next;
210 }
211
212 /* unregister children */
213 if (c->children)
214 {
215 for (c2 = c->children; c2; c2 = c2->next)
216 {
217 free(c2->name);
218 if (c2->help)
219 free(c2->help);
220 free(c2);
221 }
222 }
223
224 /* delete command */
225 free(c->name);
226 if (c->help)
227 free(c->help);
228 free(c);
229 }
230
231 /* remember the last command for unlinking */
232 p = c;
233 }
234
235 return ERROR_OK;
236 }
237
238 int parse_line(char *line, char *words[], int max_words)
239 {
240 int nwords = 0;
241 char *p = line;
242 char *word_start = line;
243 int inquote = 0;
244
245 while (nwords < max_words - 1)
246 {
247 /* check if we reached
248 * a terminating NUL
249 * a matching closing quote character " or '
250 * we're inside a word but not a quote, and the current character is whitespace
251 */
252 if (!*p || *p == inquote || (word_start && !inquote && isspace(*p)))
253 {
254 /* we're inside a word or quote, and reached its end*/
255 if (word_start)
256 {
257 int len;
258 char *word_end=p;
259
260 /* This will handle extra whitespace within quotes */
261 while (isspace(*word_start)&&(word_start<word_end))
262 word_start++;
263 while (isspace(*(word_end-1))&&(word_start<word_end))
264 word_end--;
265 len = word_end - word_start;
266
267 if (len>0)
268 {
269 /* copy the word */
270 memcpy(words[nwords] = malloc(len + 1), word_start, len);
271 /* add terminating NUL */
272 words[nwords++][len] = 0;
273 }
274 }
275 /* we're done parsing the line */
276 if (!*p)
277 break;
278
279 /* skip over trailing quote or whitespace*/
280 if (inquote || isspace(*p))
281 p++;
282 while (isspace(*p))
283 p++;
284
285 inquote = 0;
286 word_start = 0;
287 }
288 else if (*p == '"' || *p == '\'')
289 {
290 /* we've reached the beginning of a quote */
291 inquote = *p++;
292 word_start = p;
293 }
294 else
295 {
296 /* we've reached the beginning of a new word */
297 if (!word_start)
298 word_start = p;
299
300 /* normal character, skip */
301 p++;
302 }
303 }
304
305 return nwords;
306 }
307
308 void command_output_text(command_context_t *context, const char *data)
309 {
310 if( context && context->output_handler && data ){
311 context->output_handler( context, data );
312 }
313 }
314
315 void command_print_n(command_context_t *context, char *format, ...)
316 {
317 char *string;
318
319 va_list ap;
320 va_start(ap, format);
321
322 string = alloc_vprintf(format, ap);
323 if (string != NULL)
324 {
325 context->output_handler(context, string);
326 free(string);
327 }
328
329 va_end(ap);
330 }
331
332 void command_print(command_context_t *context, char *format, ...)
333 {
334 char *string;
335
336 va_list ap;
337 va_start(ap, format);
338
339 string = alloc_vprintf(format, ap);
340 if (string != NULL)
341 {
342 strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
343 context->output_handler(context, string);
344 free(string);
345 }
346
347 va_end(ap);
348 }
349
350 command_t *find_command(command_context_t *context, command_t *commands, char *words[], int num_words, int start_word, int *new_start_word)
351 {
352 command_t *c;
353
354 if (unique_length_dirty)
355 {
356 unique_length_dirty = 0;
357 /* update unique lengths */
358 build_unique_lengths(context, context->commands);
359 }
360
361 for (c = commands; c; c = c->next)
362 {
363 if (strncasecmp(c->name, words[start_word], c->unique_len))
364 continue;
365
366 if (strncasecmp(c->name, words[start_word], strlen(words[start_word])))
367 continue;
368
369 if ((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) )
370 {
371 if (!c->children)
372 {
373 if (!c->handler)
374 {
375 return NULL;
376 }
377 else
378 {
379 *new_start_word=start_word;
380 return c;
381 }
382 }
383 else
384 {
385 if (start_word == num_words - 1)
386 {
387 return NULL;
388 }
389 return find_command(context, c->children, words, num_words, start_word + 1, new_start_word);
390 }
391 }
392 }
393 return NULL;
394 }
395
396 int find_and_run_command(command_context_t *context, command_t *commands, char *words[], int num_words)
397 {
398 int start_word=0;
399 command_t *c;
400 c = find_command(context, commands, words, num_words, start_word, &start_word);
401 if (c == NULL)
402 {
403 /* just return command not found */
404 return ERROR_COMMAND_NOTFOUND;
405 }
406
407 int retval = c->handler(context, c->name, words + start_word + 1, num_words - start_word - 1);
408 if (retval == ERROR_COMMAND_SYNTAX_ERROR)
409 {
410 command_print(context, "Syntax error:");
411 command_print_help_line(context, c, 0);
412 }
413 else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
414 {
415 /* just fall through for a shutdown request */
416 }
417 else if (retval != ERROR_OK)
418 {
419 /* we do not print out an error message because the command *should*
420 * have printed out an error
421 */
422 LOG_DEBUG("Command failed with error code %d", retval);
423 }
424
425 return retval;
426 }
427
428 int command_run_line_internal(command_context_t *context, char *line)
429 {
430 LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
431
432 int nwords;
433 char *words[128] = {0};
434 int retval;
435 int i;
436
437 /* skip preceding whitespace */
438 while (isspace(*line))
439 line++;
440
441 /* empty line, ignore */
442 if (!*line)
443 return ERROR_OK;
444
445 /* ignore comments */
446 if (*line && (line[0] == '#'))
447 return ERROR_OK;
448
449 LOG_DEBUG("%s", line);
450
451 nwords = parse_line(line, words, sizeof(words) / sizeof(words[0]));
452
453 if (nwords > 0)
454 {
455 retval = find_and_run_command(context, context->commands, words, nwords);
456 }
457 else
458 return ERROR_INVALID_ARGUMENTS;
459
460 for (i = 0; i < nwords; i++)
461 free(words[i]);
462
463 return retval;
464 }
465
466 int command_run_line(command_context_t *context, char *line)
467 {
468 /* if a command is unknown to the "unknown" proc in tcl/commands.tcl will
469 * redirect it to OpenOCD.
470 *
471 * This avoids having to type the "openocd" prefix and makes OpenOCD
472 * commands "native" to Tcl.
473 */
474 return jim_command(context, line);
475 }
476
477
478 int command_run_linef(command_context_t *context, char *format, ...)
479 {
480 int retval=ERROR_FAIL;
481 char *string;
482 va_list ap;
483 va_start(ap, format);
484 string = alloc_vprintf(format, ap);
485 if (string!=NULL)
486 {
487 retval=command_run_line(context, string);
488 }
489 va_end(ap);
490 return retval;
491 }
492
493 void command_print_help_line(command_context_t* context, struct command_s *command, int indent)
494 {
495 command_t *c;
496 char *indent_text=malloc(indent + 2);
497
498 char *help = "no help available";
499 char name_buf[64];
500
501 if (indent)
502 {
503 indent_text[0] = ' ';
504 memset(indent_text + 1, '-', indent);
505 indent_text[indent + 1] = 0;
506 }
507
508 if (command->help)
509 help = command->help;
510
511 snprintf(name_buf, 64, command->name);
512
513 if (indent)
514 strncat(name_buf, indent_text, 64);
515
516 command_print(context, "%20s\t%s", name_buf, help, indent);
517
518 if (command->children)
519 {
520 for (c = command->children; c; c = c->next)
521 {
522 command_print_help_line(context, c, indent + 1);
523 }
524 }
525 free(indent_text);
526 }
527
528 int command_print_help_match(command_context_t* context, command_t* c_first, char* name, char** args, int argc)
529 {
530 command_t * c;
531
532 for (c = c_first; c; c = c->next)
533 {
534 if (argc > 0)
535 {
536 if (strncasecmp(c->name, args[0], c->unique_len))
537 continue;
538
539 if (strncasecmp(c->name, args[0], strlen(args[0])))
540 continue;
541
542 if (argc > 1)
543 {
544 command_print_help_match(context, c->children, name, args + 1, argc - 1);
545 continue;
546 }
547 }
548
549 command_print_help_line(context, c, 0);
550 }
551
552 return ERROR_OK;
553 }
554
555 int command_print_help(command_context_t* context, char* name, char** args, int argc)
556 {
557 return command_print_help_match(context, context->commands, name, args, argc);
558 }
559
560 void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
561 {
562 context->output_handler = output_handler;
563 context->output_handler_priv = priv;
564 }
565
566 command_context_t* copy_command_context(command_context_t* context)
567 {
568 command_context_t* copy_context = malloc(sizeof(command_context_t));
569
570 *copy_context = *context;
571
572 return copy_context;
573 }
574
575 int command_done(command_context_t *context)
576 {
577 free(context);
578 context = NULL;
579
580 return ERROR_OK;
581 }
582
583 command_context_t* command_init()
584 {
585 command_context_t* context = malloc(sizeof(command_context_t));
586
587 context->mode = COMMAND_EXEC;
588 context->commands = NULL;
589 context->current_target = 0;
590 context->output_handler = NULL;
591 context->output_handler_priv = NULL;
592
593 register_command(context, NULL, "help", command_print_help,
594 COMMAND_EXEC, "display this help");
595
596 register_command(context, NULL, "sleep", handle_sleep_command,
597 COMMAND_ANY, "sleep for <n> milliseconds");
598
599 register_command(context, NULL, "time", handle_time_command,
600 COMMAND_ANY, "time <cmd + args> - execute <cmd + args> and print time it took");
601
602 register_command(context, NULL, "fast", handle_fast_command,
603 COMMAND_ANY, "fast <enable/disable> - place at beginning of config files. Sets defaults to fast and dangerous.");
604
605 return context;
606 }
607
608 /* sleep command sleeps for <n> miliseconds
609 * this is useful in target startup scripts
610 */
611 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
612 {
613 unsigned long duration = 0;
614
615 if (argc == 1)
616 {
617 duration = strtoul(args[0], NULL, 0);
618 usleep(duration * 1000);
619 }
620
621 return ERROR_OK;
622 }
623
624 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
625 {
626 if (argc!=1)
627 return ERROR_COMMAND_SYNTAX_ERROR;
628
629 fast_and_dangerous = strcmp("enable", args[0])==0;
630
631 return ERROR_OK;
632 }
633
634
635 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
636 {
637 duration_t duration;
638 char *duration_text;
639 int retval;
640 float t;
641
642 if (argc<1)
643 return ERROR_COMMAND_SYNTAX_ERROR;
644
645 duration_start_measure(&duration);
646
647 retval = find_and_run_command(cmd_ctx, cmd_ctx->commands, args, argc);
648 if (retval == ERROR_COMMAND_NOTFOUND)
649 {
650 command_print(cmd_ctx, "Command %s not found", args[0]);
651 }
652
653 duration_stop_measure(&duration, &duration_text);
654
655 t=duration.duration.tv_sec;
656 t+=((float)duration.duration.tv_usec / 1000000.0);
657 command_print(cmd_ctx, "%s took %fs", args[0], t);
658
659 free(duration_text);
660
661 return retval;
662 }

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)