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