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