git.gag.com Git - fw/openocd/blob - src/helper/command.c

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