helper/command: check for malloc failure in __command_name
[openocd.git] / src / helper / command.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
10 * *
11 * part of this file is taken from libcli (libcli.sourceforge.net) *
12 * Copyright (C) David Parrish (david@dparrish.com) *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
26 ***************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 /* see Embedded-HOWTO.txt in Jim Tcl project hosted on BerliOS*/
33 #define JIM_EMBEDDED
34
35 /* @todo the inclusion of target.h here is a layering violation */
36 #include <jtag/jtag.h>
37 #include <target/target.h>
38 #include "command.h"
39 #include "configuration.h"
40 #include "log.h"
41 #include "time_support.h"
42 #include "jim-eventloop.h"
43
44 /* nice short description of source file */
45 #define __THIS__FILE__ "command.c"
46
47 static int run_command(struct command_context *context,
48 struct command *c, const char *words[], unsigned num_words);
49
50 struct log_capture_state {
51 Jim_Interp *interp;
52 Jim_Obj *output;
53 };
54
55 static void tcl_output(void *privData, const char *file, unsigned line,
56 const char *function, const char *string)
57 {
58 struct log_capture_state *state = privData;
59 Jim_AppendString(state->interp, state->output, string, strlen(string));
60 }
61
62 static struct log_capture_state *command_log_capture_start(Jim_Interp *interp)
63 {
64 /* capture log output and return it. A garbage collect can
65 * happen, so we need a reference count to this object */
66 Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
67 if (NULL == tclOutput)
68 return NULL;
69
70 struct log_capture_state *state = malloc(sizeof(*state));
71 if (NULL == state)
72 return NULL;
73
74 state->interp = interp;
75 Jim_IncrRefCount(tclOutput);
76 state->output = tclOutput;
77
78 log_add_callback(tcl_output, state);
79
80 return state;
81 }
82
83 /* Classic openocd commands provide progress output which we
84 * will capture and return as a Tcl return value.
85 *
86 * However, if a non-openocd command has been invoked, then it
87 * makes sense to return the tcl return value from that command.
88 *
89 * The tcl return value is empty for openocd commands that provide
90 * progress output.
91 *
92 * Therefore we set the tcl return value only if we actually
93 * captured output.
94 */
95 static void command_log_capture_finish(struct log_capture_state *state)
96 {
97 if (NULL == state)
98 return;
99
100 log_remove_callback(tcl_output, state);
101
102 int length;
103 Jim_GetString(state->output, &length);
104
105 if (length > 0)
106 Jim_SetResult(state->interp, state->output);
107 else {
108 /* No output captured, use tcl return value (which could
109 * be empty too). */
110 }
111 Jim_DecrRefCount(state->interp, state->output);
112
113 free(state);
114 }
115
116 static int command_retval_set(Jim_Interp *interp, int retval)
117 {
118 int *return_retval = Jim_GetAssocData(interp, "retval");
119 if (return_retval != NULL)
120 *return_retval = retval;
121
122 return (retval == ERROR_OK) ? JIM_OK : retval;
123 }
124
125 extern struct command_context *global_cmd_ctx;
126
127 /* dump a single line to the log for the command.
128 * Do nothing in case we are not at debug level 3 */
129 void script_debug(Jim_Interp *interp, const char *name,
130 unsigned argc, Jim_Obj * const *argv)
131 {
132 if (debug_level < LOG_LVL_DEBUG)
133 return;
134
135 char *dbg = alloc_printf("command - %s", name);
136 for (unsigned i = 0; i < argc; i++) {
137 int len;
138 const char *w = Jim_GetString(argv[i], &len);
139 char *t = alloc_printf("%s %s", dbg, w);
140 free(dbg);
141 dbg = t;
142 }
143 LOG_DEBUG("%s", dbg);
144 free(dbg);
145 }
146
147 static void script_command_args_free(char **words, unsigned nwords)
148 {
149 for (unsigned i = 0; i < nwords; i++)
150 free(words[i]);
151 free(words);
152 }
153
154 static char **script_command_args_alloc(
155 unsigned argc, Jim_Obj * const *argv, unsigned *nwords)
156 {
157 char **words = malloc(argc * sizeof(char *));
158 if (NULL == words)
159 return NULL;
160
161 unsigned i;
162 for (i = 0; i < argc; i++) {
163 int len;
164 const char *w = Jim_GetString(argv[i], &len);
165 words[i] = strdup(w);
166 if (words[i] == NULL) {
167 script_command_args_free(words, i);
168 return NULL;
169 }
170 }
171 *nwords = i;
172 return words;
173 }
174
175 struct command_context *current_command_context(Jim_Interp *interp)
176 {
177 /* grab the command context from the associated data */
178 struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
179 if (NULL == cmd_ctx) {
180 /* Tcl can invoke commands directly instead of via command_run_line(). This would
181 * happen when the Jim Tcl interpreter is provided by eCos or if we are running
182 * commands in a startup script.
183 *
184 * A telnet or gdb server would provide a non-default command context to
185 * handle piping of error output, have a separate current target, etc.
186 */
187 cmd_ctx = global_cmd_ctx;
188 }
189 return cmd_ctx;
190 }
191
192 static int script_command_run(Jim_Interp *interp,
193 int argc, Jim_Obj * const *argv, struct command *c, bool capture)
194 {
195 target_call_timer_callbacks_now();
196 LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
197
198 unsigned nwords;
199 char **words = script_command_args_alloc(argc, argv, &nwords);
200 if (NULL == words)
201 return JIM_ERR;
202
203 struct log_capture_state *state = NULL;
204 if (capture)
205 state = command_log_capture_start(interp);
206
207 struct command_context *cmd_ctx = current_command_context(interp);
208 int retval = run_command(cmd_ctx, c, (const char **)words, nwords);
209
210 command_log_capture_finish(state);
211
212 script_command_args_free(words, nwords);
213 return command_retval_set(interp, retval);
214 }
215
216 static int script_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
217 {
218 /* the private data is stashed in the interp structure */
219
220 struct command *c = interp->cmdPrivData;
221 assert(c);
222 script_debug(interp, c->name, argc, argv);
223 return script_command_run(interp, argc, argv, c, true);
224 }
225
226 static struct command *command_root(struct command *c)
227 {
228 while (NULL != c->parent)
229 c = c->parent;
230 return c;
231 }
232
233 /**
234 * Find a command by name from a list of commands.
235 * @returns Returns the named command if it exists in the list.
236 * Returns NULL otherwise.
237 */
238 static struct command *command_find(struct command *head, const char *name)
239 {
240 for (struct command *cc = head; cc; cc = cc->next) {
241 if (strcmp(cc->name, name) == 0)
242 return cc;
243 }
244 return NULL;
245 }
246
247 struct command *command_find_in_context(struct command_context *cmd_ctx,
248 const char *name)
249 {
250 return command_find(cmd_ctx->commands, name);
251 }
252 struct command *command_find_in_parent(struct command *parent,
253 const char *name)
254 {
255 return command_find(parent->children, name);
256 }
257
258 /**
259 * Add the command into the linked list, sorted by name.
260 * @param head Address to head of command list pointer, which may be
261 * updated if @c c gets inserted at the beginning of the list.
262 * @param c The command to add to the list pointed to by @c head.
263 */
264 static void command_add_child(struct command **head, struct command *c)
265 {
266 assert(head);
267 if (NULL == *head) {
268 *head = c;
269 return;
270 }
271
272 while ((*head)->next && (strcmp(c->name, (*head)->name) > 0))
273 head = &(*head)->next;
274
275 if (strcmp(c->name, (*head)->name) > 0) {
276 c->next = (*head)->next;
277 (*head)->next = c;
278 } else {
279 c->next = *head;
280 *head = c;
281 }
282 }
283
284 static struct command **command_list_for_parent(
285 struct command_context *cmd_ctx, struct command *parent)
286 {
287 return parent ? &parent->children : &cmd_ctx->commands;
288 }
289
290 static void command_free(struct command *c)
291 {
292 /** @todo if command has a handler, unregister its jim command! */
293
294 while (NULL != c->children) {
295 struct command *tmp = c->children;
296 c->children = tmp->next;
297 command_free(tmp);
298 }
299
300 free(c->name);
301 free(c->help);
302 free(c->usage);
303 free(c);
304 }
305
306 static struct command *command_new(struct command_context *cmd_ctx,
307 struct command *parent, const struct command_registration *cr)
308 {
309 assert(cr->name);
310
311 /*
312 * If it is a non-jim command with no .usage specified,
313 * log an error.
314 *
315 * strlen(.usage) == 0 means that the command takes no
316 * arguments.
317 */
318 if ((cr->jim_handler == NULL) && (cr->usage == NULL)) {
319 LOG_DEBUG("BUG: command '%s%s%s' does not have the "
320 "'.usage' field filled out",
321 parent && parent->name ? parent->name : "",
322 parent && parent->name ? " " : "",
323 cr->name);
324 }
325
326 struct command *c = calloc(1, sizeof(struct command));
327 if (NULL == c)
328 return NULL;
329
330 c->name = strdup(cr->name);
331 if (cr->help)
332 c->help = strdup(cr->help);
333 if (cr->usage)
334 c->usage = strdup(cr->usage);
335
336 if (!c->name || (cr->help && !c->help) || (cr->usage && !c->usage))
337 goto command_new_error;
338
339 c->parent = parent;
340 c->handler = cr->handler;
341 c->jim_handler = cr->jim_handler;
342 c->jim_handler_data = cr->jim_handler_data;
343 c->mode = cr->mode;
344
345 command_add_child(command_list_for_parent(cmd_ctx, parent), c);
346
347 return c;
348
349 command_new_error:
350 command_free(c);
351 return NULL;
352 }
353
354 static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
355
356 static int register_command_handler(struct command_context *cmd_ctx,
357 struct command *c)
358 {
359 Jim_Interp *interp = cmd_ctx->interp;
360 char *ocd_name = alloc_printf("ocd_%s", c->name);
361 if (NULL == ocd_name)
362 return JIM_ERR;
363
364 LOG_DEBUG("registering '%s'...", ocd_name);
365
366 Jim_CmdProc *func = c->handler ? &script_command : &command_unknown;
367 int retval = Jim_CreateCommand(interp, ocd_name, func, c, NULL);
368 free(ocd_name);
369 if (JIM_OK != retval)
370 return retval;
371
372 /* we now need to add an overrideable proc */
373 char *override_name = alloc_printf(
374 "proc %s {args} {eval ocd_bouncer %s $args}",
375 c->name, c->name);
376 if (NULL == override_name)
377 return JIM_ERR;
378
379 retval = Jim_Eval_Named(interp, override_name, 0, 0);
380 free(override_name);
381
382 return retval;
383 }
384
385 struct command *register_command(struct command_context *context,
386 struct command *parent, const struct command_registration *cr)
387 {
388 if (!context || !cr->name)
389 return NULL;
390
391 const char *name = cr->name;
392 struct command **head = command_list_for_parent(context, parent);
393 struct command *c = command_find(*head, name);
394 if (NULL != c) {
395 /* TODO: originally we treated attempting to register a cmd twice as an error
396 * Sometimes we need this behaviour, such as with flash banks.
397 * http://www.mail-archive.com/openocd-development@lists.berlios.de/msg11152.html */
398 LOG_DEBUG("command '%s' is already registered in '%s' context",
399 name, parent ? parent->name : "<global>");
400 return c;
401 }
402
403 c = command_new(context, parent, cr);
404 if (NULL == c)
405 return NULL;
406
407 int retval = ERROR_OK;
408 if (NULL != cr->jim_handler && NULL == parent) {
409 retval = Jim_CreateCommand(context->interp, cr->name,
410 cr->jim_handler, cr->jim_handler_data, NULL);
411 } else if (NULL != cr->handler || NULL != parent)
412 retval = register_command_handler(context, command_root(c));
413
414 if (ERROR_OK != retval) {
415 unregister_command(context, parent, name);
416 c = NULL;
417 }
418 return c;
419 }
420
421 int register_commands(struct command_context *cmd_ctx, struct command *parent,
422 const struct command_registration *cmds)
423 {
424 int retval = ERROR_OK;
425 unsigned i;
426 for (i = 0; cmds[i].name || cmds[i].chain; i++) {
427 const struct command_registration *cr = cmds + i;
428
429 struct command *c = NULL;
430 if (NULL != cr->name) {
431 c = register_command(cmd_ctx, parent, cr);
432 if (NULL == c) {
433 retval = ERROR_FAIL;
434 break;
435 }
436 }
437 if (NULL != cr->chain) {
438 struct command *p = c ? : parent;
439 retval = register_commands(cmd_ctx, p, cr->chain);
440 if (ERROR_OK != retval)
441 break;
442 }
443 }
444 if (ERROR_OK != retval) {
445 for (unsigned j = 0; j < i; j++)
446 unregister_command(cmd_ctx, parent, cmds[j].name);
447 }
448 return retval;
449 }
450
451 int unregister_all_commands(struct command_context *context,
452 struct command *parent)
453 {
454 if (context == NULL)
455 return ERROR_OK;
456
457 struct command **head = command_list_for_parent(context, parent);
458 while (NULL != *head) {
459 struct command *tmp = *head;
460 *head = tmp->next;
461 command_free(tmp);
462 }
463
464 return ERROR_OK;
465 }
466
467 int unregister_command(struct command_context *context,
468 struct command *parent, const char *name)
469 {
470 if ((!context) || (!name))
471 return ERROR_COMMAND_SYNTAX_ERROR;
472
473 struct command *p = NULL;
474 struct command **head = command_list_for_parent(context, parent);
475 for (struct command *c = *head; NULL != c; p = c, c = c->next) {
476 if (strcmp(name, c->name) != 0)
477 continue;
478
479 if (p)
480 p->next = c->next;
481 else
482 *head = c->next;
483
484 command_free(c);
485 return ERROR_OK;
486 }
487
488 return ERROR_OK;
489 }
490
491 void command_set_handler_data(struct command *c, void *p)
492 {
493 if (NULL != c->handler || NULL != c->jim_handler)
494 c->jim_handler_data = p;
495 for (struct command *cc = c->children; NULL != cc; cc = cc->next)
496 command_set_handler_data(cc, p);
497 }
498
499 void command_output_text(struct command_context *context, const char *data)
500 {
501 if (context && context->output_handler && data)
502 context->output_handler(context, data);
503 }
504
505 void command_print_sameline(struct command_context *context, const char *format, ...)
506 {
507 char *string;
508
509 va_list ap;
510 va_start(ap, format);
511
512 string = alloc_vprintf(format, ap);
513 if (string != NULL) {
514 /* we want this collected in the log + we also want to pick it up as a tcl return
515 * value.
516 *
517 * The latter bit isn't precisely neat, but will do for now.
518 */
519 LOG_USER_N("%s", string);
520 /* We already printed it above
521 * command_output_text(context, string); */
522 free(string);
523 }
524
525 va_end(ap);
526 }
527
528 void command_print(struct command_context *context, const char *format, ...)
529 {
530 char *string;
531
532 va_list ap;
533 va_start(ap, format);
534
535 string = alloc_vprintf(format, ap);
536 if (string != NULL) {
537 strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one
538 *char longer */
539 /* we want this collected in the log + we also want to pick it up as a tcl return
540 * value.
541 *
542 * The latter bit isn't precisely neat, but will do for now.
543 */
544 LOG_USER_N("%s", string);
545 /* We already printed it above
546 * command_output_text(context, string); */
547 free(string);
548 }
549
550 va_end(ap);
551 }
552
553 static char *__command_name(struct command *c, char delim, unsigned extra)
554 {
555 char *name;
556 unsigned len = strlen(c->name);
557 if (NULL == c->parent) {
558 /* allocate enough for the name, child names, and '\0' */
559 name = malloc(len + extra + 1);
560 if (!name) {
561 LOG_ERROR("Out of memory");
562 return NULL;
563 }
564 strcpy(name, c->name);
565 } else {
566 /* parent's extra must include both the space and name */
567 name = __command_name(c->parent, delim, 1 + len + extra);
568 char dstr[2] = { delim, 0 };
569 strcat(name, dstr);
570 strcat(name, c->name);
571 }
572 return name;
573 }
574
575 char *command_name(struct command *c, char delim)
576 {
577 return __command_name(c, delim, 0);
578 }
579
580 static bool command_can_run(struct command_context *cmd_ctx, struct command *c)
581 {
582 return c->mode == COMMAND_ANY || c->mode == cmd_ctx->mode;
583 }
584
585 static int run_command(struct command_context *context,
586 struct command *c, const char *words[], unsigned num_words)
587 {
588 if (!command_can_run(context, c)) {
589 /* Many commands may be run only before/after 'init' */
590 const char *when;
591 switch (c->mode) {
592 case COMMAND_CONFIG:
593 when = "before";
594 break;
595 case COMMAND_EXEC:
596 when = "after";
597 break;
598 /* handle the impossible with humor; it guarantees a bug report! */
599 default:
600 when = "if Cthulhu is summoned by";
601 break;
602 }
603 LOG_ERROR("The '%s' command must be used %s 'init'.",
604 c->name, when);
605 return ERROR_FAIL;
606 }
607
608 struct command_invocation cmd = {
609 .ctx = context,
610 .current = c,
611 .name = c->name,
612 .argc = num_words - 1,
613 .argv = words + 1,
614 };
615 /* Black magic of overridden current target:
616 * If the command we are going to handle has a target prefix,
617 * override the current target temporarily for the time
618 * of processing the command.
619 * current_target_override is used also for event handlers
620 * therefore we prevent touching it if command has no prefix.
621 * Previous override is saved and restored back to ensure
622 * correct work when run_command() is re-entered. */
623 struct target *saved_target_override = context->current_target_override;
624 if (c->jim_handler_data)
625 context->current_target_override = c->jim_handler_data;
626
627 int retval = c->handler(&cmd);
628
629 if (c->jim_handler_data)
630 context->current_target_override = saved_target_override;
631
632 if (retval == ERROR_COMMAND_SYNTAX_ERROR) {
633 /* Print help for command */
634 char *full_name = command_name(c, ' ');
635 if (NULL != full_name) {
636 command_run_linef(context, "usage %s", full_name);
637 free(full_name);
638 }
639 } else if (retval == ERROR_COMMAND_CLOSE_CONNECTION) {
640 /* just fall through for a shutdown request */
641 } else if (retval != ERROR_OK) {
642 /* we do not print out an error message because the command *should*
643 * have printed out an error
644 */
645 LOG_DEBUG("Command '%s' failed with error code %d", c->name, retval);
646 }
647
648 return retval;
649 }
650
651 int command_run_line(struct command_context *context, char *line)
652 {
653 /* all the parent commands have been registered with the interpreter
654 * so, can just evaluate the line as a script and check for
655 * results
656 */
657 /* run the line thru a script engine */
658 int retval = ERROR_FAIL;
659 int retcode;
660 /* Beware! This code needs to be reentrant. It is also possible
661 * for OpenOCD commands to be invoked directly from Tcl. This would
662 * happen when the Jim Tcl interpreter is provided by eCos for
663 * instance.
664 */
665 context->current_target_override = NULL;
666
667 Jim_Interp *interp = context->interp;
668 Jim_DeleteAssocData(interp, "context");
669 retcode = Jim_SetAssocData(interp, "context", NULL, context);
670 if (retcode == JIM_OK) {
671 /* associated the return value */
672 Jim_DeleteAssocData(interp, "retval");
673 retcode = Jim_SetAssocData(interp, "retval", NULL, &retval);
674 if (retcode == JIM_OK) {
675 retcode = Jim_Eval_Named(interp, line, 0, 0);
676
677 Jim_DeleteAssocData(interp, "retval");
678 }
679 Jim_DeleteAssocData(interp, "context");
680 }
681 if (retcode == JIM_OK) {
682 const char *result;
683 int reslen;
684
685 result = Jim_GetString(Jim_GetResult(interp), &reslen);
686 if (reslen > 0) {
687 int i;
688 char buff[256 + 1];
689 for (i = 0; i < reslen; i += 256) {
690 int chunk;
691 chunk = reslen - i;
692 if (chunk > 256)
693 chunk = 256;
694 strncpy(buff, result + i, chunk);
695 buff[chunk] = 0;
696 LOG_USER_N("%s", buff);
697 }
698 LOG_USER_N("\n");
699 }
700 retval = ERROR_OK;
701 } else if (retcode == JIM_EXIT) {
702 /* ignore.
703 * exit(Jim_GetExitCode(interp)); */
704 } else if (retcode == ERROR_COMMAND_CLOSE_CONNECTION) {
705 return retcode;
706 } else {
707 Jim_MakeErrorMessage(interp);
708 LOG_USER("%s", Jim_GetString(Jim_GetResult(interp), NULL));
709
710 if (retval == ERROR_OK) {
711 /* It wasn't a low level OpenOCD command that failed */
712 return ERROR_FAIL;
713 }
714 return retval;
715 }
716
717 return retval;
718 }
719
720 int command_run_linef(struct command_context *context, const char *format, ...)
721 {
722 int retval = ERROR_FAIL;
723 char *string;
724 va_list ap;
725 va_start(ap, format);
726 string = alloc_vprintf(format, ap);
727 if (string != NULL) {
728 retval = command_run_line(context, string);
729 free(string);
730 }
731 va_end(ap);
732 return retval;
733 }
734
735 void command_set_output_handler(struct command_context *context,
736 command_output_handler_t output_handler, void *priv)
737 {
738 context->output_handler = output_handler;
739 context->output_handler_priv = priv;
740 }
741
742 struct command_context *copy_command_context(struct command_context *context)
743 {
744 struct command_context *copy_context = malloc(sizeof(struct command_context));
745
746 *copy_context = *context;
747
748 return copy_context;
749 }
750
751 void command_done(struct command_context *cmd_ctx)
752 {
753 if (NULL == cmd_ctx)
754 return;
755
756 free(cmd_ctx);
757 }
758
759 /* find full path to file */
760 static int jim_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
761 {
762 if (argc != 2)
763 return JIM_ERR;
764 const char *file = Jim_GetString(argv[1], NULL);
765 char *full_path = find_file(file);
766 if (full_path == NULL)
767 return JIM_ERR;
768 Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path));
769 free(full_path);
770
771 Jim_SetResult(interp, result);
772 return JIM_OK;
773 }
774
775 COMMAND_HANDLER(jim_echo)
776 {
777 if (CMD_ARGC == 2 && !strcmp(CMD_ARGV[0], "-n")) {
778 LOG_USER_N("%s", CMD_ARGV[1]);
779 return JIM_OK;
780 }
781 if (CMD_ARGC != 1)
782 return JIM_ERR;
783 LOG_USER("%s", CMD_ARGV[0]);
784 return JIM_OK;
785 }
786
787 /* Capture progress output and return as tcl return value. If the
788 * progress output was empty, return tcl return value.
789 */
790 static int jim_capture(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
791 {
792 if (argc != 2)
793 return JIM_ERR;
794
795 struct log_capture_state *state = command_log_capture_start(interp);
796
797 /* disable polling during capture. This avoids capturing output
798 * from polling.
799 *
800 * This is necessary in order to avoid accidentally getting a non-empty
801 * string for tcl fn's.
802 */
803 bool save_poll = jtag_poll_get_enabled();
804
805 jtag_poll_set_enabled(false);
806
807 const char *str = Jim_GetString(argv[1], NULL);
808 int retcode = Jim_Eval_Named(interp, str, __THIS__FILE__, __LINE__);
809
810 jtag_poll_set_enabled(save_poll);
811
812 command_log_capture_finish(state);
813
814 return retcode;
815 }
816
817 static COMMAND_HELPER(command_help_find, struct command *head,
818 struct command **out)
819 {
820 if (0 == CMD_ARGC)
821 return ERROR_COMMAND_SYNTAX_ERROR;
822 *out = command_find(head, CMD_ARGV[0]);
823 if (NULL == *out && strncmp(CMD_ARGV[0], "ocd_", 4) == 0)
824 *out = command_find(head, CMD_ARGV[0] + 4);
825 if (NULL == *out)
826 return ERROR_COMMAND_SYNTAX_ERROR;
827 if (--CMD_ARGC == 0)
828 return ERROR_OK;
829 CMD_ARGV++;
830 return CALL_COMMAND_HANDLER(command_help_find, (*out)->children, out);
831 }
832
833 static COMMAND_HELPER(command_help_show, struct command *c, unsigned n,
834 bool show_help, const char *cmd_match);
835
836 static COMMAND_HELPER(command_help_show_list, struct command *head, unsigned n,
837 bool show_help, const char *cmd_match)
838 {
839 for (struct command *c = head; NULL != c; c = c->next)
840 CALL_COMMAND_HANDLER(command_help_show, c, n, show_help, cmd_match);
841 return ERROR_OK;
842 }
843
844 #define HELP_LINE_WIDTH(_n) (int)(76 - (2 * _n))
845
846 static void command_help_show_indent(unsigned n)
847 {
848 for (unsigned i = 0; i < n; i++)
849 LOG_USER_N(" ");
850 }
851 static void command_help_show_wrap(const char *str, unsigned n, unsigned n2)
852 {
853 const char *cp = str, *last = str;
854 while (*cp) {
855 const char *next = last;
856 do {
857 cp = next;
858 do {
859 next++;
860 } while (*next != ' ' && *next != '\t' && *next != '\0');
861 } while ((next - last < HELP_LINE_WIDTH(n)) && *next != '\0');
862 if (next - last < HELP_LINE_WIDTH(n))
863 cp = next;
864 command_help_show_indent(n);
865 LOG_USER("%.*s", (int)(cp - last), last);
866 last = cp + 1;
867 n = n2;
868 }
869 }
870
871 static COMMAND_HELPER(command_help_show, struct command *c, unsigned n,
872 bool show_help, const char *cmd_match)
873 {
874 char *cmd_name = command_name(c, ' ');
875 if (NULL == cmd_name)
876 return ERROR_FAIL;
877
878 /* If the match string occurs anywhere, we print out
879 * stuff for this command. */
880 bool is_match = (strstr(cmd_name, cmd_match) != NULL) ||
881 ((c->usage != NULL) && (strstr(c->usage, cmd_match) != NULL)) ||
882 ((c->help != NULL) && (strstr(c->help, cmd_match) != NULL));
883
884 if (is_match) {
885 command_help_show_indent(n);
886 LOG_USER_N("%s", cmd_name);
887 }
888 free(cmd_name);
889
890 if (is_match) {
891 if (c->usage && strlen(c->usage) > 0) {
892 LOG_USER_N(" ");
893 command_help_show_wrap(c->usage, 0, n + 5);
894 } else
895 LOG_USER_N("\n");
896 }
897
898 if (is_match && show_help) {
899 char *msg;
900
901 /* Normal commands are runtime-only; highlight exceptions */
902 if (c->mode != COMMAND_EXEC) {
903 const char *stage_msg = "";
904
905 switch (c->mode) {
906 case COMMAND_CONFIG:
907 stage_msg = " (configuration command)";
908 break;
909 case COMMAND_ANY:
910 stage_msg = " (command valid any time)";
911 break;
912 default:
913 stage_msg = " (?mode error?)";
914 break;
915 }
916 msg = alloc_printf("%s%s", c->help ? : "", stage_msg);
917 } else
918 msg = alloc_printf("%s", c->help ? : "");
919
920 if (NULL != msg) {
921 command_help_show_wrap(msg, n + 3, n + 3);
922 free(msg);
923 } else
924 return -ENOMEM;
925 }
926
927 if (++n > 5) {
928 LOG_ERROR("command recursion exceeded");
929 return ERROR_FAIL;
930 }
931
932 return CALL_COMMAND_HANDLER(command_help_show_list,
933 c->children, n, show_help, cmd_match);
934 }
935
936 COMMAND_HANDLER(handle_help_command)
937 {
938 bool full = strcmp(CMD_NAME, "help") == 0;
939 int retval;
940 struct command *c = CMD_CTX->commands;
941 char *cmd_match = NULL;
942
943 if (CMD_ARGC == 0)
944 cmd_match = "";
945 else if (CMD_ARGC >= 1) {
946 unsigned i;
947
948 for (i = 0; i < CMD_ARGC; ++i) {
949 if (NULL != cmd_match) {
950 char *prev = cmd_match;
951
952 cmd_match = alloc_printf("%s %s", cmd_match, CMD_ARGV[i]);
953 free(prev);
954 if (NULL == cmd_match) {
955 LOG_ERROR("unable to build search string");
956 return -ENOMEM;
957 }
958 } else {
959 cmd_match = alloc_printf("%s", CMD_ARGV[i]);
960 if (NULL == cmd_match) {
961 LOG_ERROR("unable to build search string");
962 return -ENOMEM;
963 }
964 }
965 }
966 } else
967 return ERROR_COMMAND_SYNTAX_ERROR;
968
969 retval = CALL_COMMAND_HANDLER(command_help_show_list,
970 c, 0, full, cmd_match);
971
972 if (CMD_ARGC >= 1)
973 free(cmd_match);
974 return retval;
975 }
976
977 static int command_unknown_find(unsigned argc, Jim_Obj *const *argv,
978 struct command *head, struct command **out, bool top_level)
979 {
980 if (0 == argc)
981 return argc;
982 const char *cmd_name = Jim_GetString(argv[0], NULL);
983 struct command *c = command_find(head, cmd_name);
984 if (NULL == c && top_level && strncmp(cmd_name, "ocd_", 4) == 0)
985 c = command_find(head, cmd_name + 4);
986 if (NULL == c)
987 return argc;
988 *out = c;
989 return command_unknown_find(--argc, ++argv, (*out)->children, out, false);
990 }
991
992 static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
993 {
994 const char *cmd_name = Jim_GetString(argv[0], NULL);
995 if (strcmp(cmd_name, "unknown") == 0) {
996 if (argc == 1)
997 return JIM_OK;
998 argc--;
999 argv++;
1000 }
1001 script_debug(interp, cmd_name, argc, argv);
1002
1003 struct command_context *cmd_ctx = current_command_context(interp);
1004 struct command *c = cmd_ctx->commands;
1005 int remaining = command_unknown_find(argc, argv, c, &c, true);
1006 /* if nothing could be consumed, then it's really an unknown command */
1007 if (remaining == argc) {
1008 const char *cmd = Jim_GetString(argv[0], NULL);
1009 LOG_ERROR("Unknown command:\n %s", cmd);
1010 return JIM_OK;
1011 }
1012
1013 bool found = true;
1014 Jim_Obj *const *start;
1015 unsigned count;
1016 if (c->handler || c->jim_handler) {
1017 /* include the command name in the list */
1018 count = remaining + 1;
1019 start = argv + (argc - remaining - 1);
1020 } else {
1021 c = command_find(cmd_ctx->commands, "usage");
1022 if (NULL == c) {
1023 LOG_ERROR("unknown command, but usage is missing too");
1024 return JIM_ERR;
1025 }
1026 count = argc - remaining;
1027 start = argv;
1028 found = false;
1029 }
1030 /* pass the command through to the intended handler */
1031 if (c->jim_handler) {
1032 interp->cmdPrivData = c->jim_handler_data;
1033 return (*c->jim_handler)(interp, count, start);
1034 }
1035
1036 return script_command_run(interp, count, start, c, found);
1037 }
1038
1039 static int jim_command_mode(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1040 {
1041 struct command_context *cmd_ctx = current_command_context(interp);
1042 enum command_mode mode;
1043
1044 if (argc > 1) {
1045 struct command *c = cmd_ctx->commands;
1046 int remaining = command_unknown_find(argc - 1, argv + 1, c, &c, true);
1047 /* if nothing could be consumed, then it's an unknown command */
1048 if (remaining == argc - 1) {
1049 Jim_SetResultString(interp, "unknown", -1);
1050 return JIM_OK;
1051 }
1052 mode = c->mode;
1053 } else
1054 mode = cmd_ctx->mode;
1055
1056 const char *mode_str;
1057 switch (mode) {
1058 case COMMAND_ANY:
1059 mode_str = "any";
1060 break;
1061 case COMMAND_CONFIG:
1062 mode_str = "config";
1063 break;
1064 case COMMAND_EXEC:
1065 mode_str = "exec";
1066 break;
1067 default:
1068 mode_str = "unknown";
1069 break;
1070 }
1071 Jim_SetResultString(interp, mode_str, -1);
1072 return JIM_OK;
1073 }
1074
1075 static int jim_command_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1076 {
1077 if (1 == argc)
1078 return JIM_ERR;
1079
1080 struct command_context *cmd_ctx = current_command_context(interp);
1081 struct command *c = cmd_ctx->commands;
1082 int remaining = command_unknown_find(argc - 1, argv + 1, c, &c, true);
1083 /* if nothing could be consumed, then it's an unknown command */
1084 if (remaining == argc - 1) {
1085 Jim_SetResultString(interp, "unknown", -1);
1086 return JIM_OK;
1087 }
1088
1089 if (c->jim_handler)
1090 Jim_SetResultString(interp, "native", -1);
1091 else if (c->handler)
1092 Jim_SetResultString(interp, "simple", -1);
1093 else if (remaining == 0)
1094 Jim_SetResultString(interp, "group", -1);
1095 else
1096 Jim_SetResultString(interp, "unknown", -1);
1097
1098 return JIM_OK;
1099 }
1100
1101 int help_add_command(struct command_context *cmd_ctx, struct command *parent,
1102 const char *cmd_name, const char *help_text, const char *usage)
1103 {
1104 struct command **head = command_list_for_parent(cmd_ctx, parent);
1105 struct command *nc = command_find(*head, cmd_name);
1106 if (NULL == nc) {
1107 /* add a new command with help text */
1108 struct command_registration cr = {
1109 .name = cmd_name,
1110 .mode = COMMAND_ANY,
1111 .help = help_text,
1112 .usage = usage,
1113 };
1114 nc = register_command(cmd_ctx, parent, &cr);
1115 if (NULL == nc) {
1116 LOG_ERROR("failed to add '%s' help text", cmd_name);
1117 return ERROR_FAIL;
1118 }
1119 LOG_DEBUG("added '%s' help text", cmd_name);
1120 return ERROR_OK;
1121 }
1122 if (help_text) {
1123 bool replaced = false;
1124 if (nc->help) {
1125 free(nc->help);
1126 replaced = true;
1127 }
1128 nc->help = strdup(help_text);
1129 if (replaced)
1130 LOG_INFO("replaced existing '%s' help", cmd_name);
1131 else
1132 LOG_DEBUG("added '%s' help text", cmd_name);
1133 }
1134 if (usage) {
1135 bool replaced = false;
1136 if (nc->usage) {
1137 free(nc->usage);
1138 replaced = true;
1139 }
1140 nc->usage = strdup(usage);
1141 if (replaced)
1142 LOG_INFO("replaced existing '%s' usage", cmd_name);
1143 else
1144 LOG_DEBUG("added '%s' usage text", cmd_name);
1145 }
1146 return ERROR_OK;
1147 }
1148
1149 COMMAND_HANDLER(handle_help_add_command)
1150 {
1151 if (CMD_ARGC < 2) {
1152 LOG_ERROR("%s: insufficient arguments", CMD_NAME);
1153 return ERROR_COMMAND_SYNTAX_ERROR;
1154 }
1155
1156 /* save help text and remove it from argument list */
1157 const char *str = CMD_ARGV[--CMD_ARGC];
1158 const char *help = !strcmp(CMD_NAME, "add_help_text") ? str : NULL;
1159 const char *usage = !strcmp(CMD_NAME, "add_usage_text") ? str : NULL;
1160 if (!help && !usage) {
1161 LOG_ERROR("command name '%s' is unknown", CMD_NAME);
1162 return ERROR_COMMAND_SYNTAX_ERROR;
1163 }
1164 /* likewise for the leaf command name */
1165 const char *cmd_name = CMD_ARGV[--CMD_ARGC];
1166
1167 struct command *c = NULL;
1168 if (CMD_ARGC > 0) {
1169 c = CMD_CTX->commands;
1170 int retval = CALL_COMMAND_HANDLER(command_help_find, c, &c);
1171 if (ERROR_OK != retval)
1172 return retval;
1173 }
1174 return help_add_command(CMD_CTX, c, cmd_name, help, usage);
1175 }
1176
1177 /* sleep command sleeps for <n> milliseconds
1178 * this is useful in target startup scripts
1179 */
1180 COMMAND_HANDLER(handle_sleep_command)
1181 {
1182 bool busy = false;
1183 if (CMD_ARGC == 2) {
1184 if (strcmp(CMD_ARGV[1], "busy") == 0)
1185 busy = true;
1186 else
1187 return ERROR_COMMAND_SYNTAX_ERROR;
1188 } else if (CMD_ARGC < 1 || CMD_ARGC > 2)
1189 return ERROR_COMMAND_SYNTAX_ERROR;
1190
1191 unsigned long duration = 0;
1192 int retval = parse_ulong(CMD_ARGV[0], &duration);
1193 if (ERROR_OK != retval)
1194 return retval;
1195
1196 if (!busy) {
1197 int64_t then = timeval_ms();
1198 while (timeval_ms() - then < (int64_t)duration) {
1199 target_call_timer_callbacks_now();
1200 usleep(1000);
1201 }
1202 } else
1203 busy_sleep(duration);
1204
1205 return ERROR_OK;
1206 }
1207
1208 static const struct command_registration command_subcommand_handlers[] = {
1209 {
1210 .name = "mode",
1211 .mode = COMMAND_ANY,
1212 .jim_handler = jim_command_mode,
1213 .usage = "[command_name ...]",
1214 .help = "Returns the command modes allowed by a command:"
1215 "'any', 'config', or 'exec'. If no command is"
1216 "specified, returns the current command mode. "
1217 "Returns 'unknown' if an unknown command is given. "
1218 "Command can be multiple tokens.",
1219 },
1220 {
1221 .name = "type",
1222 .mode = COMMAND_ANY,
1223 .jim_handler = jim_command_type,
1224 .usage = "command_name [...]",
1225 .help = "Returns the type of built-in command:"
1226 "'native', 'simple', 'group', or 'unknown'. "
1227 "Command can be multiple tokens.",
1228 },
1229 COMMAND_REGISTRATION_DONE
1230 };
1231
1232 static const struct command_registration command_builtin_handlers[] = {
1233 {
1234 .name = "echo",
1235 .handler = jim_echo,
1236 .mode = COMMAND_ANY,
1237 .help = "Logs a message at \"user\" priority. "
1238 "Output message to stdout. "
1239 "Option \"-n\" suppresses trailing newline",
1240 .usage = "[-n] string",
1241 },
1242 {
1243 .name = "add_help_text",
1244 .handler = handle_help_add_command,
1245 .mode = COMMAND_ANY,
1246 .help = "Add new command help text; "
1247 "Command can be multiple tokens.",
1248 .usage = "command_name helptext_string",
1249 },
1250 {
1251 .name = "add_usage_text",
1252 .handler = handle_help_add_command,
1253 .mode = COMMAND_ANY,
1254 .help = "Add new command usage text; "
1255 "command can be multiple tokens.",
1256 .usage = "command_name usage_string",
1257 },
1258 {
1259 .name = "sleep",
1260 .handler = handle_sleep_command,
1261 .mode = COMMAND_ANY,
1262 .help = "Sleep for specified number of milliseconds. "
1263 "\"busy\" will busy wait instead (avoid this).",
1264 .usage = "milliseconds ['busy']",
1265 },
1266 {
1267 .name = "help",
1268 .handler = handle_help_command,
1269 .mode = COMMAND_ANY,
1270 .help = "Show full command help; "
1271 "command can be multiple tokens.",
1272 .usage = "[command_name]",
1273 },
1274 {
1275 .name = "usage",
1276 .handler = handle_help_command,
1277 .mode = COMMAND_ANY,
1278 .help = "Show basic command usage; "
1279 "command can be multiple tokens.",
1280 .usage = "[command_name]",
1281 },
1282 {
1283 .name = "command",
1284 .mode = COMMAND_ANY,
1285 .help = "core command group (introspection)",
1286 .chain = command_subcommand_handlers,
1287 },
1288 COMMAND_REGISTRATION_DONE
1289 };
1290
1291 struct command_context *command_init(const char *startup_tcl, Jim_Interp *interp)
1292 {
1293 struct command_context *context = calloc(1, sizeof(struct command_context));
1294 const char *HostOs;
1295
1296 context->mode = COMMAND_EXEC;
1297
1298 /* Create a jim interpreter if we were not handed one */
1299 if (interp == NULL) {
1300 /* Create an interpreter */
1301 interp = Jim_CreateInterp();
1302 /* Add all the Jim core commands */
1303 Jim_RegisterCoreCommands(interp);
1304 Jim_InitStaticExtensions(interp);
1305 }
1306
1307 context->interp = interp;
1308
1309 /* Stick to lowercase for HostOS strings. */
1310 #if defined(_MSC_VER)
1311 /* WinXX - is generic, the forward
1312 * looking problem is this:
1313 *
1314 * "win32" or "win64"
1315 *
1316 * "winxx" is generic.
1317 */
1318 HostOs = "winxx";
1319 #elif defined(__linux__)
1320 HostOs = "linux";
1321 #elif defined(__APPLE__) || defined(__DARWIN__)
1322 HostOs = "darwin";
1323 #elif defined(__CYGWIN__)
1324 HostOs = "cygwin";
1325 #elif defined(__MINGW32__)
1326 HostOs = "mingw32";
1327 #elif defined(__ECOS)
1328 HostOs = "ecos";
1329 #elif defined(__FreeBSD__)
1330 HostOs = "freebsd";
1331 #elif defined(__NetBSD__)
1332 HostOs = "netbsd";
1333 #elif defined(__OpenBSD__)
1334 HostOs = "openbsd";
1335 #else
1336 #warning "Unrecognized host OS..."
1337 HostOs = "other";
1338 #endif
1339 Jim_SetGlobalVariableStr(interp, "ocd_HOSTOS",
1340 Jim_NewStringObj(interp, HostOs, strlen(HostOs)));
1341
1342 Jim_CreateCommand(interp, "ocd_find", jim_find, NULL, NULL);
1343 Jim_CreateCommand(interp, "capture", jim_capture, NULL, NULL);
1344
1345 register_commands(context, NULL, command_builtin_handlers);
1346
1347 Jim_SetAssocData(interp, "context", NULL, context);
1348 if (Jim_Eval_Named(interp, startup_tcl, "embedded:startup.tcl", 1) == JIM_ERR) {
1349 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1350 Jim_MakeErrorMessage(interp);
1351 LOG_USER_N("%s", Jim_GetString(Jim_GetResult(interp), NULL));
1352 exit(-1);
1353 }
1354 Jim_DeleteAssocData(interp, "context");
1355
1356 return context;
1357 }
1358
1359 void command_exit(struct command_context *context)
1360 {
1361 if (!context)
1362 return;
1363
1364 Jim_FreeInterp(context->interp);
1365 command_done(context);
1366 }
1367
1368 int command_context_mode(struct command_context *cmd_ctx, enum command_mode mode)
1369 {
1370 if (!cmd_ctx)
1371 return ERROR_COMMAND_SYNTAX_ERROR;
1372
1373 cmd_ctx->mode = mode;
1374 return ERROR_OK;
1375 }
1376
1377 void process_jim_events(struct command_context *cmd_ctx)
1378 {
1379 static int recursion;
1380 if (recursion)
1381 return;
1382
1383 recursion++;
1384 Jim_ProcessEvents(cmd_ctx->interp, JIM_ALL_EVENTS | JIM_DONT_WAIT);
1385 recursion--;
1386 }
1387
1388 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1389 int parse ## name(const char *str, type * ul) \
1390 { \
1391 if (!*str) { \
1392 LOG_ERROR("Invalid command argument"); \
1393 return ERROR_COMMAND_ARGUMENT_INVALID; \
1394 } \
1395 char *end; \
1396 *ul = func(str, &end, 0); \
1397 if (*end) { \
1398 LOG_ERROR("Invalid command argument"); \
1399 return ERROR_COMMAND_ARGUMENT_INVALID; \
1400 } \
1401 if ((max == *ul) && (ERANGE == errno)) { \
1402 LOG_ERROR("Argument overflow"); \
1403 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1404 } \
1405 if (min && (min == *ul) && (ERANGE == errno)) { \
1406 LOG_ERROR("Argument underflow"); \
1407 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1408 } \
1409 return ERROR_OK; \
1410 }
1411 DEFINE_PARSE_NUM_TYPE(_ulong, unsigned long, strtoul, 0, ULONG_MAX)
1412 DEFINE_PARSE_NUM_TYPE(_ullong, unsigned long long, strtoull, 0, ULLONG_MAX)
1413 DEFINE_PARSE_NUM_TYPE(_long, long, strtol, LONG_MIN, LONG_MAX)
1414 DEFINE_PARSE_NUM_TYPE(_llong, long long, strtoll, LLONG_MIN, LLONG_MAX)
1415
1416 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1417 int parse ## name(const char *str, type * ul) \
1418 { \
1419 functype n; \
1420 int retval = parse ## funcname(str, &n); \
1421 if (ERROR_OK != retval) \
1422 return retval; \
1423 if (n > max) \
1424 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1425 if (min) \
1426 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1427 *ul = n; \
1428 return ERROR_OK; \
1429 }
1430
1431 #define DEFINE_PARSE_ULONGLONG(name, type, min, max) \
1432 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long long, _ullong)
1433 DEFINE_PARSE_ULONGLONG(_uint, unsigned, 0, UINT_MAX)
1434 DEFINE_PARSE_ULONGLONG(_u64, uint64_t, 0, UINT64_MAX)
1435 DEFINE_PARSE_ULONGLONG(_u32, uint32_t, 0, UINT32_MAX)
1436 DEFINE_PARSE_ULONGLONG(_u16, uint16_t, 0, UINT16_MAX)
1437 DEFINE_PARSE_ULONGLONG(_u8, uint8_t, 0, UINT8_MAX)
1438
1439 DEFINE_PARSE_ULONGLONG(_target_addr, target_addr_t, 0, TARGET_ADDR_MAX)
1440
1441 #define DEFINE_PARSE_LONGLONG(name, type, min, max) \
1442 DEFINE_PARSE_WRAPPER(name, type, min, max, long long, _llong)
1443 DEFINE_PARSE_LONGLONG(_int, int, n < INT_MIN, INT_MAX)
1444 DEFINE_PARSE_LONGLONG(_s64, int64_t, n < INT64_MIN, INT64_MAX)
1445 DEFINE_PARSE_LONGLONG(_s32, int32_t, n < INT32_MIN, INT32_MAX)
1446 DEFINE_PARSE_LONGLONG(_s16, int16_t, n < INT16_MIN, INT16_MAX)
1447 DEFINE_PARSE_LONGLONG(_s8, int8_t, n < INT8_MIN, INT8_MAX)
1448
1449 static int command_parse_bool(const char *in, bool *out,
1450 const char *on, const char *off)
1451 {
1452 if (strcasecmp(in, on) == 0)
1453 *out = true;
1454 else if (strcasecmp(in, off) == 0)
1455 *out = false;
1456 else
1457 return ERROR_COMMAND_SYNTAX_ERROR;
1458 return ERROR_OK;
1459 }
1460
1461 int command_parse_bool_arg(const char *in, bool *out)
1462 {
1463 if (command_parse_bool(in, out, "on", "off") == ERROR_OK)
1464 return ERROR_OK;
1465 if (command_parse_bool(in, out, "enable", "disable") == ERROR_OK)
1466 return ERROR_OK;
1467 if (command_parse_bool(in, out, "true", "false") == ERROR_OK)
1468 return ERROR_OK;
1469 if (command_parse_bool(in, out, "yes", "no") == ERROR_OK)
1470 return ERROR_OK;
1471 if (command_parse_bool(in, out, "1", "0") == ERROR_OK)
1472 return ERROR_OK;
1473 return ERROR_COMMAND_SYNTAX_ERROR;
1474 }
1475
1476 COMMAND_HELPER(handle_command_parse_bool, bool *out, const char *label)
1477 {
1478 switch (CMD_ARGC) {
1479 case 1: {
1480 const char *in = CMD_ARGV[0];
1481 if (command_parse_bool_arg(in, out) != ERROR_OK) {
1482 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME, in);
1483 return ERROR_COMMAND_SYNTAX_ERROR;
1484 }
1485 }
1486 /* fallthrough */
1487 case 0:
1488 LOG_INFO("%s is %s", label, *out ? "enabled" : "disabled");
1489 break;
1490 default:
1491 return ERROR_COMMAND_SYNTAX_ERROR;
1492 }
1493 return ERROR_OK;
1494 }