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