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  *   part of this file is taken from libcli (libcli.sourceforge.net)       *
   6  *   Copyright (C) David Parrish (david@dparrish.com)                      *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU General Public License as published by  *
  10  *   the Free Software Foundation; either version 2 of the License, or     *
  11  *   (at your option) any later version.                                   *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU General Public License     *
  19  *   along with this program; if not, write to the                         *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  22  ***************************************************************************/
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "replacements.h"
  28
  29 #include "command.h"
  30
  31 #include "log.h"
  32 #include "time_support.h"
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include <stdarg.h>
  38 #include <stdio.h>
  39 #include <unistd.h>
  40
  41 int fast_and_dangerous = 0;
  42
  43 void command_print_help_line(command_context_t* context, struct command_s *command, int indent);
  44
  45 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  46 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  47 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  48
  49 /* forward declaration of jim_command */
  50 extern int jim_command(command_context_t *context, char *line);
  51
  52 int build_unique_lengths(command_context_t *context, command_t *commands)
  53 {
  54         command_t *c, *p;
  55
  56         /* iterate through all commands */
  57         for (c = commands; c; c = c->next)
  58         {
  59                 /* find out how many characters are required to uniquely identify a command */
  60                 for (c->unique_len = 1; c->unique_len <= strlen(c->name); c->unique_len++)
  61                 {
  62                         int foundmatch = 0;
  63
  64                         /* for every command, see if the current length is enough */
  65                         for (p = commands; p; p = p->next)
  66                         {
  67                                 /* ignore the command itself */
  68                                 if (c == p)
  69                                         continue;
  70
  71                                 /* compare commands up to the current length */
  72                                 if (strncmp(p->name, c->name, c->unique_len) == 0)
  73                                         foundmatch++;
  74                         }
  75
  76                         /* when none of the commands matched, we've found the minimum length required */
  77                         if (!foundmatch)
  78                                 break;
  79                 }
  80
  81                 /* if the current command has children, build the unique lengths for them */
  82                 if (c->children)
  83                         build_unique_lengths(context, c->children);
  84         }
  85
  86         return ERROR_OK;
  87 }
  88
  89 /* Avoid evaluating this each time we add a command. Reduces overhead from O(n^2) to O(n).
  90  * Makes a difference on ARM7 types machines and is not observable on GHz machines.
  91  */
  92 static int unique_length_dirty = 1;
  93
  94 command_t* register_command(command_context_t *context, command_t *parent, char *name, int (*handler)(struct command_context_s *context, char* name, char** args, int argc), enum command_mode mode, char *help)
  95 {
  96         command_t *c, *p;
  97         unique_length_dirty = 1;
  98
  99         if (!context || !name)
 100                 return NULL;
 101
 102         c = malloc(sizeof(command_t));
 103
 104         c->name = strdup(name);
 105         c->parent = parent;
 106         c->children = NULL;
 107         c->handler = handler;
 108         c->mode = mode;
 109         if (help)
 110                 c->help = strdup(help);
 111         else
 112                 c->help = NULL;
 113         c->unique_len = 0;
 114         c->next = NULL;
 115
 116         /* place command in tree */
 117         if (parent)
 118         {
 119                 if (parent->children)
 120                 {
 121                         /* find last child */
 122                         for (p = parent->children; p && p->next; p = p->next);
 123                         if (p)
 124                                 p->next = c;
 125                 }
 126                 else
 127                 {
 128                         parent->children = c;
 129                 }
 130         }
 131         else
 132         {
 133                 if (context->commands)
 134                 {
 135                         /* find last command */
 136                         for (p = context->commands; p && p->next; p = p->next);
 137                         if (p)
 138                                 p->next = c;
 139                 }
 140                 else
 141                 {
 142                         context->commands = c;
 143                 }
 144         }
 145
 146         return c;
 147 }
 148
 149 int unregister_all_commands(command_context_t *context)
 150 {
 151         command_t *c, *c2;
 152
 153         unique_length_dirty = 1;
 154
 155         if (context == NULL)
 156                 return ERROR_OK;
 157
 158
 159         while(NULL != context->commands)
 160         {
 161                 c = context->commands;
 162
 163                 while(NULL != c->children)
 164                 {
 165                         c2 = c->children;
 166                         c->children = c->children->next;
 167                         free(c2->name);
 168                         c2->name = NULL;
 169                         free(c2->help);
 170                         c2->help = NULL;
 171                         free(c2);
 172                         c2 = NULL;
 173                 }
 174
 175                 context->commands = context->commands->next;
 176
 177                 free(c->name);
 178                 c->name = NULL;
 179                 free(c->help);
 180                 c->help = NULL;
 181                 free(c);
 182                 c = NULL;
 183         }
 184
 185         return ERROR_OK;
 186 }
 187
 188 int unregister_command(command_context_t *context, char *name)
 189 {
 190         command_t *c, *p = NULL, *c2;
 191
 192         unique_length_dirty = 1;
 193
 194         if ((!context) || (!name))
 195                 return ERROR_INVALID_ARGUMENTS;
 196
 197         /* find command */
 198         for (c = context->commands; c; c = c->next)
 199         {
 200                 if (strcmp(name, c->name) == 0)
 201                 {
 202                         /* unlink command */
 203                         if (p)
 204                         {
 205                                 p->next = c->next;
 206                         }
 207                         else
 208                         {
 209                                 context->commands = c->next;
 210                         }
 211
 212                         /* unregister children */
 213                         if (c->children)
 214                         {
 215                                 for (c2 = c->children; c2; c2 = c2->next)
 216                                 {
 217                                         free(c2->name);
 218                                         if (c2->help)
 219                                                 free(c2->help);
 220                                         free(c2);
 221                                 }
 222                         }
 223
 224                         /* delete command */
 225                         free(c->name);
 226                         if (c->help)
 227                                 free(c->help);
 228                         free(c);
 229                 }
 230
 231                 /* remember the last command for unlinking */
 232                 p = c;
 233         }
 234
 235         return ERROR_OK;
 236 }
 237
 238 int parse_line(char *line, char *words[], int max_words)
 239 {
 240         int nwords = 0;
 241         char *p = line;
 242         char *word_start = line;
 243         int inquote = 0;
 244
 245         while (nwords < max_words - 1)
 246         {
 247                 /* check if we reached
 248                  * a terminating NUL
 249                  * a matching closing quote character " or '
 250                  * we're inside a word but not a quote, and the current character is whitespace
 251                  */
 252                 if (!*p || *p == inquote || (word_start && !inquote && isspace(*p)))
 253                 {
 254                         /* we're inside a word or quote, and reached its end*/
 255                         if (word_start)
 256                         {
 257                                 int len;
 258                                 char *word_end=p;
 259
 260                                 /* This will handle extra whitespace within quotes */
 261                                 while (isspace(*word_start)&&(word_start<word_end))
 262                                         word_start++;
 263                                 while (isspace(*(word_end-1))&&(word_start<word_end))
 264                                         word_end--;
 265                                 len = word_end - word_start;
 266
 267                                 if (len>0)
 268                                 {
 269                                         /* copy the word */
 270                                         memcpy(words[nwords] = malloc(len + 1), word_start, len);
 271                                         /* add terminating NUL */
 272                                         words[nwords++][len] = 0;
 273                                 }
 274                         }
 275                         /* we're done parsing the line */
 276                         if (!*p)
 277                                 break;
 278
 279                         /* skip over trailing quote or whitespace*/
 280                         if (inquote || isspace(*p))
 281                                 p++;
 282                         while (isspace(*p))
 283                                 p++;
 284
 285                         inquote = 0;
 286                         word_start = 0;
 287                 }
 288                 else if (*p == '"' || *p == '\'')
 289                 {
 290                         /* we've reached the beginning of a quote */
 291                         inquote = *p++;
 292                         word_start = p;
 293                 }
 294                 else
 295                 {
 296                         /* we've reached the beginning of a new word */
 297                         if (!word_start)
 298                                 word_start = p;
 299
 300                         /* normal character, skip */
 301                         p++;
 302                 }
 303         }
 304
 305         return nwords;
 306 }
 307
 308 void command_output_text(command_context_t *context, const char *data)
 309 {
 310         if( context && context->output_handler && data  ){
 311                 context->output_handler( context, data );
 312         }
 313 }
 314
 315 void command_print_n(command_context_t *context, char *format, ...)
 316 {
 317         char *string;
 318
 319         va_list ap;
 320         va_start(ap, format);
 321
 322         string = alloc_vprintf(format, ap);
 323         if (string != NULL)
 324         {
 325                 context->output_handler(context, string);
 326                 free(string);
 327         }
 328
 329         va_end(ap);
 330 }
 331
 332 void command_print(command_context_t *context, char *format, ...)
 333 {
 334         char *string;
 335
 336         va_list ap;
 337         va_start(ap, format);
 338
 339         string = alloc_vprintf(format, ap);
 340         if (string != NULL)
 341         {
 342                 strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
 343                 context->output_handler(context, string);
 344                 free(string);
 345         }
 346
 347         va_end(ap);
 348 }
 349
 350 command_t *find_command(command_context_t *context, command_t *commands, char *words[], int num_words, int start_word, int *new_start_word)
 351 {
 352         command_t *c;
 353
 354         if (unique_length_dirty)
 355         {
 356                 unique_length_dirty = 0;
 357                 /* update unique lengths */
 358                 build_unique_lengths(context, context->commands);
 359         }
 360
 361         for (c = commands; c; c = c->next)
 362         {
 363                 if (strncasecmp(c->name, words[start_word], c->unique_len))
 364                         continue;
 365
 366                 if (strncasecmp(c->name, words[start_word], strlen(words[start_word])))
 367                         continue;
 368
 369                 if ((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) )
 370                 {
 371                         if (!c->children)
 372                         {
 373                                 if (!c->handler)
 374                                 {
 375                                         return NULL;
 376                                 }
 377                                 else
 378                                 {
 379                                         *new_start_word=start_word;
 380                                         return c;
 381                                 }
 382                         }
 383                         else
 384                         {
 385                                 if (start_word == num_words - 1)
 386                                 {
 387                                         return NULL;
 388                                 }
 389                                 return find_command(context, c->children, words, num_words, start_word + 1, new_start_word);
 390                         }
 391                 }
 392         }
 393         return NULL;
 394 }
 395
 396 int find_and_run_command(command_context_t *context, command_t *commands, char *words[], int num_words)
 397 {
 398         int start_word=0;
 399         command_t *c;
 400         c=find_command(context, commands, words, num_words, start_word, &start_word);
 401         if (c==NULL)
 402         {
 403                 command_print(context, "Command %s not found", words[start_word]);
 404                 return ERROR_COMMAND_SYNTAX_ERROR;
 405         }
 406
 407         int retval = c->handler(context, c->name, words + start_word + 1, num_words - start_word - 1);
 408         if (retval == ERROR_COMMAND_SYNTAX_ERROR)
 409         {
 410                 command_print(context, "Syntax error:");
 411                 command_print_help_line(context, c, 0);
 412         }
 413         else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
 414         {
 415                 /* just fall through for a shutdown request */
 416         }
 417         else if (retval != ERROR_OK)
 418         {
 419                 /* we do not print out an error message because the command *should*
 420                  * have printed out an error
 421                  */
 422                 LOG_DEBUG("Command failed with error code %d", retval);
 423         }
 424         return retval;
 425 }
 426
 427 int command_run_line_internal_op(command_context_t *context, char *line, int run)
 428 {
 429         LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
 430
 431         int nwords;
 432         char *words[128] = {0};
 433         int retval;
 434         int i;
 435
 436         /* skip preceding whitespace */
 437         while (isspace(*line))
 438                 line++;
 439
 440         /* empty line, ignore */
 441         if (!*line)
 442                 return ERROR_OK;
 443
 444         /* ignore comments */
 445         if (*line && (line[0] == '#'))
 446                 return ERROR_OK;
 447
 448         if (run)
 449         {
 450                 LOG_DEBUG("%s", line);
 451         }
 452
 453         nwords = parse_line(line, words, sizeof(words) / sizeof(words[0]));
 454
 455         if (nwords > 0)
 456         {
 457                 if (run)
 458                 {
 459                         retval = find_and_run_command(context, context->commands, words, nwords);
 460                 } else
 461                 {
 462                         int t;
 463                         return (find_command(context, context->commands, words, nwords, 0, &t)!=NULL)?ERROR_OK:ERROR_FAIL;
 464                 }
 465         }
 466         else
 467                 return ERROR_INVALID_ARGUMENTS;
 468
 469         for (i = 0; i < nwords; i++)
 470                 free(words[i]);
 471
 472         return retval;
 473 }
 474
 475 int command_run_line_internal(command_context_t *context, char *line)
 476 {
 477         return command_run_line_internal_op(context, line, 1);
 478 }
 479
 480 int command_run_line(command_context_t *context, char *line)
 481 {
 482         if ((!context) || (!line))
 483                 return ERROR_INVALID_ARGUMENTS;
 484
 485         if (command_run_line_internal_op(context, line, 0)!=ERROR_OK)
 486         {
 487                 /* If we can't find a command, then try the interpreter.
 488                  * If there is no interpreter implemented, then this will
 489                  * simply print a syntax error.
 490                  *
 491                  * These hooks were left in to reduce patch size for
 492                  * wip to add scripting language.
 493                  */
 494                 return jim_command(context, line);
 495         }
 496
 497         return command_run_line_internal(context, line);
 498 }
 499
 500 int command_run_file(command_context_t *context, FILE *file, enum command_mode mode)
 501 {
 502         int retval = ERROR_OK;
 503         int old_command_mode;
 504         char *buffer=malloc(4096);
 505         if (buffer==NULL)
 506         {
 507                 return ERROR_INVALID_ARGUMENTS;
 508         }
 509
 510         old_command_mode = context->mode;
 511         context->mode = mode;
 512
 513         while (fgets(buffer, 4096, file))
 514         {
 515                 char *p;
 516                 char *cmd, *end;
 517
 518                 /* stop processing line after a comment (#, !) or a LF, CR were encountered */
 519                 if ((p = strpbrk(buffer, "#!\r\n")))
 520                         *p = 0;
 521
 522                 /* skip over leading whitespace */
 523                 cmd = buffer;
 524                 while (isspace(*cmd))
 525                         cmd++;
 526
 527                 /* empty (all whitespace) line? */
 528                 if (!*cmd)
 529                         continue;
 530
 531                 /* search the end of the current line, ignore trailing whitespace */
 532                 for (p = end = cmd; *p; p++)
 533                         if (!isspace(*p))
 534                                 end = p;
 535
 536                 /* terminate end */
 537                 *++end = 0;
 538                 if (strcasecmp(cmd, "quit") == 0)
 539                         break;
 540
 541                 /* run line */
 542                 if ((retval = command_run_line(context, cmd)) == ERROR_COMMAND_CLOSE_CONNECTION)
 543                         break;
 544         }
 545
 546         context->mode = old_command_mode;
 547
 548
 549         free(buffer);
 550
 551         return retval;
 552 }
 553
 554 int command_run_linef(command_context_t *context, char *format, ...)
 555 {
 556         int retval=ERROR_FAIL;
 557         char *string;
 558         va_list ap;
 559         va_start(ap, format);
 560         string = alloc_vprintf(format, ap);
 561         if (string!=NULL)
 562         {
 563                 retval=command_run_line(context, string);
 564         }
 565         va_end(ap);
 566         return retval;
 567 }
 568
 569 void command_print_help_line(command_context_t* context, struct command_s *command, int indent)
 570 {
 571         command_t *c;
 572         char *indent_text=malloc(indent + 2);
 573
 574         char *help = "no help available";
 575         char name_buf[64];
 576
 577         if (indent)
 578         {
 579             indent_text[0] = ' ';
 580             memset(indent_text + 1, '-', indent);
 581             indent_text[indent + 1] = 0;
 582         }
 583
 584         if (command->help)
 585                 help = command->help;
 586
 587         snprintf(name_buf, 64, command->name);
 588
 589         if (indent)
 590             strncat(name_buf, indent_text, 64);
 591
 592         command_print(context, "%20s\t%s", name_buf, help, indent);
 593
 594         if (command->children)
 595         {
 596                 for (c = command->children; c; c = c->next)
 597                 {
 598                         command_print_help_line(context, c, indent + 1);
 599                 }
 600         }
 601         free(indent_text);
 602 }
 603
 604 int command_print_help_match(command_context_t* context, command_t* c_first, char* name, char** args, int argc)
 605 {
 606         command_t * c;
 607
 608         for (c = c_first; c; c = c->next)
 609         {
 610                 if (argc > 0)
 611                 {
 612                         if (strncasecmp(c->name, args[0], c->unique_len))
 613                                 continue;
 614
 615                         if (strncasecmp(c->name, args[0], strlen(args[0])))
 616                                 continue;
 617
 618                         if (argc > 1)
 619                         {
 620                                 command_print_help_match(context, c->children, name, args + 1, argc - 1);
 621                                 continue;
 622                         }
 623                 }
 624
 625                 command_print_help_line(context, c, 0);
 626         }
 627
 628         return ERROR_OK;
 629 }
 630
 631 int command_print_help(command_context_t* context, char* name, char** args, int argc)
 632 {
 633     return command_print_help_match(context, context->commands, name, args, argc);
 634 }
 635
 636 void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
 637 {
 638         context->output_handler = output_handler;
 639         context->output_handler_priv = priv;
 640 }
 641
 642 command_context_t* copy_command_context(command_context_t* context)
 643 {
 644         command_context_t* copy_context = malloc(sizeof(command_context_t));
 645
 646         *copy_context = *context;
 647
 648         return copy_context;
 649 }
 650
 651 int command_done(command_context_t *context)
 652 {
 653         free(context);
 654         context = NULL;
 655
 656         return ERROR_OK;
 657 }
 658
 659 command_context_t* command_init()
 660 {
 661         command_context_t* context = malloc(sizeof(command_context_t));
 662
 663         context->mode = COMMAND_EXEC;
 664         context->commands = NULL;
 665         context->current_target = 0;
 666         context->output_handler = NULL;
 667         context->output_handler_priv = NULL;
 668
 669         register_command(context, NULL, "help", command_print_help,
 670                                          COMMAND_EXEC, "display this help");
 671
 672         register_command(context, NULL, "sleep", handle_sleep_command,
 673                                          COMMAND_ANY, "sleep for <n> milliseconds");
 674
 675         register_command(context, NULL, "time", handle_time_command,
 676                                          COMMAND_ANY, "time <cmd + args> - execute <cmd + args> and print time it took");
 677
 678         register_command(context, NULL, "fast", handle_fast_command,
 679                                          COMMAND_ANY, "fast <enable/disable> - place at beginning of config files. Sets defaults to fast and dangerous.");
 680
 681         return context;
 682 }
 683
 684 /* sleep command sleeps for <n> miliseconds
 685  * this is useful in target startup scripts
 686  */
 687 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 688 {
 689         unsigned long duration = 0;
 690
 691         if (argc == 1)
 692         {
 693                 duration = strtoul(args[0], NULL, 0);
 694                 usleep(duration * 1000);
 695         }
 696
 697         return ERROR_OK;
 698 }
 699
 700 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 701 {
 702         if (argc!=1)
 703                 return ERROR_COMMAND_SYNTAX_ERROR;
 704
 705         fast_and_dangerous = strcmp("enable", args[0])==0;
 706
 707         return ERROR_OK;
 708 }
 709
 710
 711 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 712 {
 713         duration_t duration;
 714         char *duration_text;
 715         int retval;
 716         float t;
 717
 718         if (argc<1)
 719                 return ERROR_COMMAND_SYNTAX_ERROR;
 720
 721         duration_start_measure(&duration);
 722
 723         retval = find_and_run_command(cmd_ctx, cmd_ctx->commands, args, argc);
 724
 725         duration_stop_measure(&duration, &duration_text);
 726
 727         t=duration.duration.tv_sec;
 728         t+=((float)duration.duration.tv_usec / 1000000.0);
 729         command_print(cmd_ctx, "%s took %fs", args[0], t);
 730
 731         free(duration_text);
 732
 733         return retval;
 734 }