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 void command_print_help_line(command_context_t* context, struct command_s *command, int indent);
  42
  43 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  44 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  45
  46 int build_unique_lengths(command_context_t *context, command_t *commands)
  47 {
  48         command_t *c, *p;
  49
  50         /* iterate through all commands */
  51         for (c = commands; c; c = c->next)
  52         {
  53                 /* find out how many characters are required to uniquely identify a command */
  54                 for (c->unique_len = 1; c->unique_len <= strlen(c->name); c->unique_len++)
  55                 {
  56                         int foundmatch = 0;
  57
  58                         /* for every command, see if the current length is enough */
  59                         for (p = commands; p; p = p->next)
  60                         {
  61                                 /* ignore the command itself */
  62                                 if (c == p)
  63                                         continue;
  64
  65                                 /* compare commands up to the current length */
  66                                 if (strncmp(p->name, c->name, c->unique_len) == 0)
  67                                         foundmatch++;
  68                         }
  69
  70                         /* when none of the commands matched, we've found the minimum length required */
  71                         if (!foundmatch)
  72                                 break;
  73                 }
  74
  75                 /* if the current command has children, build the unique lengths for them */
  76                 if (c->children)
  77                         build_unique_lengths(context, c->children);
  78         }
  79
  80         return ERROR_OK;
  81 }
  82
  83 /* Avoid evaluating this each time we add a command. Reduces overhead from O(n^2) to O(n).
  84  * Makes a difference on ARM7 types machines and is not observable on GHz machines.
  85  */
  86 static int unique_length_dirty = 1;
  87
  88 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)
  89 {
  90         command_t *c, *p;
  91         unique_length_dirty = 1;
  92
  93         if (!context || !name)
  94                 return NULL;
  95
  96         c = malloc(sizeof(command_t));
  97
  98         c->name = strdup(name);
  99         c->parent = parent;
 100         c->children = NULL;
 101         c->handler = handler;
 102         c->mode = mode;
 103         if (help)
 104                 c->help = strdup(help);
 105         else
 106                 c->help = NULL;
 107         c->unique_len = 0;
 108         c->next = NULL;
 109
 110         /* place command in tree */
 111         if (parent)
 112         {
 113                 if (parent->children)
 114                 {
 115                         /* find last child */
 116                         for (p = parent->children; p && p->next; p = p->next);
 117                         if (p)
 118                                 p->next = c;
 119                 }
 120                 else
 121                 {
 122                         parent->children = c;
 123                 }
 124         }
 125         else
 126         {
 127                 if (context->commands)
 128                 {
 129                         /* find last command */
 130                         for (p = context->commands; p && p->next; p = p->next);
 131                         if (p)
 132                                 p->next = c;
 133                 }
 134                 else
 135                 {
 136                         context->commands = c;
 137                 }
 138         }
 139
 140         return c;
 141 }
 142
 143 int unregister_command(command_context_t *context, char *name)
 144 {
 145         unique_length_dirty = 1;
 146
 147         command_t *c, *p = NULL, *c2;
 148
 149         if ((!context) || (!name))
 150                 return ERROR_INVALID_ARGUMENTS;
 151
 152         /* find command */
 153         for (c = context->commands; c; c = c->next)
 154         {
 155                 if (strcmp(name, c->name) == 0)
 156                 {
 157                         /* unlink command */
 158                         if (p)
 159                         {
 160                                 p->next = c->next;
 161                         }
 162                         else
 163                         {
 164                                 context->commands = c->next;
 165                         }
 166
 167                         /* unregister children */
 168                         if (c->children)
 169                         {
 170                                 for (c2 = c->children; c2; c2 = c2->next)
 171                                 {
 172                                         free(c2->name);
 173                                         if (c2->help)
 174                                                 free(c2->help);
 175                                         free(c2);
 176                                 }
 177                         }
 178
 179                         /* delete command */
 180                         free(c->name);
 181                         if (c->help)
 182                                 free(c->help);
 183                         free(c);
 184                 }
 185
 186                 /* remember the last command for unlinking */
 187                 p = c;
 188         }
 189
 190         return ERROR_OK;
 191 }
 192
 193 int parse_line(char *line, char *words[], int max_words)
 194 {
 195         int nwords = 0;
 196         char *p = line;
 197         char *word_start = line;
 198         int inquote = 0;
 199
 200         while (nwords < max_words - 1)
 201         {
 202                 /* check if we reached
 203                  * a terminating NUL
 204                  * a matching closing quote character " or '
 205                  * we're inside a word but not a quote, and the current character is whitespace
 206                  */
 207                 if (!*p || *p == inquote || (word_start && !inquote && isspace(*p)))
 208                 {
 209                         /* we're inside a word or quote, and reached its end*/
 210                         if (word_start)
 211                         {
 212                                 int len;
 213                                 char *word_end=p;
 214
 215                                 /* This will handle extra whitespace within quotes */
 216                                 while (isspace(*word_start)&&(word_start<word_end))
 217                                         word_start++;
 218                                 while (isspace(*(word_end-1))&&(word_start<word_end))
 219                                         word_end--;
 220                                 len = word_end - word_start;
 221
 222                                 if (len>0)
 223                                 {
 224                                         /* copy the word */
 225                                         memcpy(words[nwords] = malloc(len + 1), word_start, len);
 226                                         /* add terminating NUL */
 227                                         words[nwords++][len] = 0;
 228                                 }
 229                         }
 230                         /* we're done parsing the line */
 231                         if (!*p)
 232                                 break;
 233
 234                         /* skip over trailing quote or whitespace*/
 235                         if (inquote || isspace(*p))
 236                                 p++;
 237                         while (isspace(*p))
 238                                 p++;
 239
 240                         inquote = 0;
 241                         word_start = 0;
 242                 }
 243                 else if (*p == '"' || *p == '\'')
 244                 {
 245                         /* we've reached the beginning of a quote */
 246                         inquote = *p++;
 247                         word_start = p;
 248                 }
 249                 else
 250                 {
 251                         /* we've reached the beginning of a new word */
 252                         if (!word_start)
 253                                 word_start = p;
 254
 255                         /* normal character, skip */
 256                         p++;
 257                 }
 258         }
 259
 260         return nwords;
 261 }
 262
 263 static void command_printv(command_context_t *context, char *format, va_list ap)
 264 {
 265         char *buffer = NULL;
 266         int n, size = 0;
 267         char *p;
 268
 269         /* process format string */
 270         for (;;)
 271         {
 272                 if (!buffer || (n = vsnprintf(buffer, size, format, ap)) >= size)
 273                 {
 274                         /* increase buffer until it fits the whole string */
 275                         if (!(p = realloc(buffer, size += 4096)))
 276                         {
 277                                 /* gotta free up */
 278                                 if (buffer)
 279                                         free(buffer);
 280                                 return;
 281                         }
 282
 283                         buffer = p;
 284
 285                         continue;
 286                 }
 287                 break;
 288         }
 289
 290         /* vsnprintf failed */
 291         if (n < 0)
 292         {
 293                 if (buffer)
 294                         free(buffer);
 295                 return;
 296         }
 297
 298         context->output_handler(context, buffer);
 299
 300         if (buffer)
 301                 free(buffer);
 302 }
 303
 304 void command_print_sameline(command_context_t *context, char *format, ...)
 305 {
 306         va_list ap;
 307         va_start(ap, format);
 308         command_printv(context, format, ap);
 309         va_end(ap);
 310 }
 311
 312 void command_print(command_context_t *context, char *format, ...)
 313 {
 314         char *t=malloc(strlen(format)+2);
 315         strcpy(t, format);
 316         strcat(t, "\n");
 317         va_list ap;
 318         va_start(ap, format);
 319         command_printv(context, t, ap);
 320         va_end(ap);
 321         free(t);
 322
 323 }
 324
 325 int find_and_run_command(command_context_t *context, command_t *commands, char *words[], int num_words, int start_word)
 326 {
 327         command_t *c;
 328
 329         if (unique_length_dirty)
 330         {
 331                 unique_length_dirty = 0;
 332                 /* update unique lengths */
 333                 build_unique_lengths(context, context->commands);
 334         }
 335
 336         for (c = commands; c; c = c->next)
 337         {
 338                 if (strncasecmp(c->name, words[start_word], c->unique_len))
 339                         continue;
 340
 341                 if (strncasecmp(c->name, words[start_word], strlen(words[start_word])))
 342                         continue;
 343
 344                 if ((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) )
 345                 {
 346                         if (!c->children)
 347                         {
 348                                 if (!c->handler)
 349                                 {
 350                                         command_print(context, "No handler for command");
 351                                         break;
 352                                 }
 353                                 else
 354                                 {
 355                                         int retval = c->handler(context, c->name, words + start_word + 1, num_words - start_word - 1);
 356                                         if (retval == ERROR_COMMAND_SYNTAX_ERROR)
 357                                         {
 358                                                 command_print(context, "Syntax error:");
 359                                                 command_print_help_line(context, c, 0);
 360                                         }
 361                                         return retval;
 362                                 }
 363                         }
 364                         else
 365                         {
 366                                 if (start_word == num_words - 1)
 367                                 {
 368                                         command_print(context, "Incomplete command");
 369                                         break;
 370                                 }
 371                                 return find_and_run_command(context, c->children, words, num_words, start_word + 1);
 372                         }
 373                 }
 374         }
 375
 376         command_print(context, "Command %s not found", words[start_word]);
 377         return ERROR_OK;
 378 }
 379
 380 int command_run_line(command_context_t *context, char *line)
 381 {
 382         int nwords;
 383         char *words[128] = {0};
 384         int retval;
 385         int i;
 386
 387         if ((!context) || (!line))
 388                 return ERROR_INVALID_ARGUMENTS;
 389
 390         /* skip preceding whitespace */
 391         while (isspace(*line))
 392                 line++;
 393
 394         /* empty line, ignore */
 395         if (!*line)
 396                 return ERROR_OK;
 397
 398         /* ignore comments */
 399         if (*line && (line[0] == '#'))
 400                 return ERROR_OK;
 401
 402         DEBUG("%s", line);
 403
 404         nwords = parse_line(line, words, sizeof(words) / sizeof(words[0]));
 405
 406         if (nwords > 0)
 407                 retval = find_and_run_command(context, context->commands, words, nwords, 0);
 408         else
 409                 return ERROR_INVALID_ARGUMENTS;
 410
 411         for (i = 0; i < nwords; i++)
 412                 free(words[i]);
 413
 414         return retval;
 415 }
 416
 417 int command_run_file(command_context_t *context, FILE *file, enum command_mode mode)
 418 {
 419         int retval = ERROR_OK;
 420         int old_command_mode;
 421         char *buffer=malloc(4096);
 422         if (buffer==NULL)
 423         {
 424                 return ERROR_INVALID_ARGUMENTS;
 425         }
 426
 427         old_command_mode = context->mode;
 428         context->mode = mode;
 429
 430         while (fgets(buffer, 4096, file))
 431         {
 432                 char *p;
 433                 char *cmd, *end;
 434
 435                 /* stop processing line after a comment (#, !) or a LF, CR were encountered */
 436                 if ((p = strpbrk(buffer, "#!\r\n")))
 437                         *p = 0;
 438
 439                 /* skip over leading whitespace */
 440                 cmd = buffer;
 441                 while (isspace(*cmd))
 442                         cmd++;
 443
 444                 /* empty (all whitespace) line? */
 445                 if (!*cmd)
 446                         continue;
 447
 448                 /* search the end of the current line, ignore trailing whitespace */
 449                 for (p = end = cmd; *p; p++)
 450                         if (!isspace(*p))
 451                                 end = p;
 452
 453                 /* terminate end */
 454                 *++end = 0;
 455                 if (strcasecmp(cmd, "quit") == 0)
 456                         break;
 457
 458                 /* run line */
 459                 if ((retval = command_run_line(context, cmd)) == ERROR_COMMAND_CLOSE_CONNECTION)
 460                         break;
 461         }
 462
 463         context->mode = old_command_mode;
 464
 465
 466         free(buffer);
 467
 468         return retval;
 469 }
 470
 471 void command_print_help_line(command_context_t* context, struct command_s *command, int indent)
 472 {
 473         command_t *c;
 474         char indent_text[indent + 2];
 475         char *help = "no help available";
 476         char name_buf[64];
 477         int i;
 478
 479         if (indent)
 480         {
 481             indent_text[0] = ' ';
 482             memset(indent_text + 1, '-', indent);
 483             indent_text[indent + 1] = 0;
 484         }
 485
 486         if (command->help)
 487                 help = command->help;
 488
 489         snprintf(name_buf, 64, command->name);
 490
 491         if (indent)
 492             strncat(name_buf, indent_text, 64);
 493
 494         command_print(context, "%20s\t%s", name_buf, help, indent);
 495
 496         if (command->children)
 497         {
 498                 for (c = command->children; c; c = c->next)
 499                 {
 500                         command_print_help_line(context, c, indent + 1);
 501                 }
 502         }
 503 }
 504
 505 int command_print_help_match(command_context_t* context, command_t* c_first, char* name, char** args, int argc)
 506 {
 507         command_t * c;
 508         int i;
 509
 510         for (c = c_first; c; c = c->next)
 511         {
 512                 if (argc > 0)
 513                 {
 514                         if (strncasecmp(c->name, args[0], c->unique_len))
 515                                 continue;
 516
 517                         if (strncasecmp(c->name, args[0], strlen(args[0])))
 518                                 continue;
 519
 520                         if (argc > 1)
 521                         {
 522                                 command_print_help_match(context, c->children, name, args + 1, argc - 1);
 523                                 continue;
 524                         }
 525                 }
 526
 527                 command_print_help_line(context, c, 0);
 528         }
 529
 530         return ERROR_OK;
 531 }
 532
 533 int command_print_help(command_context_t* context, char* name, char** args, int argc)
 534 {
 535     return command_print_help_match(context, context->commands, name, args, argc);
 536 }
 537
 538
 539 void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, char* line), void *priv)
 540 {
 541         context->output_handler = output_handler;
 542         context->output_handler_priv = priv;
 543 }
 544
 545 command_context_t* copy_command_context(command_context_t* context)
 546 {
 547         command_context_t* copy_context = malloc(sizeof(command_context_t));
 548
 549         *copy_context = *context;
 550
 551         return copy_context;
 552 }
 553
 554 int command_done(command_context_t *context)
 555 {
 556         free(context);
 557         context = NULL;
 558
 559         return ERROR_OK;
 560 }
 561
 562 command_context_t* command_init()
 563 {
 564         command_context_t* context = malloc(sizeof(command_context_t));
 565
 566         context->mode = COMMAND_EXEC;
 567         context->commands = NULL;
 568         context->current_target = 0;
 569         context->output_handler = NULL;
 570         context->output_handler_priv = NULL;
 571
 572         register_command(context, NULL, "help", command_print_help,
 573                                          COMMAND_EXEC, "display this help");
 574
 575         register_command(context, NULL, "sleep", handle_sleep_command,
 576                                          COMMAND_ANY, "sleep for <n> milliseconds");
 577
 578         register_command(context, NULL, "time", handle_time_command,
 579                                          COMMAND_ANY, "time <cmd + args> - execute <cmd + args> and print time it took");
 580
 581         return context;
 582 }
 583
 584 /* sleep command sleeps for <n> miliseconds
 585  * this is useful in target startup scripts
 586  */
 587 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 588 {
 589         unsigned long duration = 0;
 590
 591         if (argc == 1)
 592         {
 593                 duration = strtoul(args[0], NULL, 0);
 594                 usleep(duration * 1000);
 595         }
 596
 597         return ERROR_OK;
 598 }
 599
 600 int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 601 {
 602         if (argc<1)
 603                 return ERROR_COMMAND_SYNTAX_ERROR;
 604
 605         duration_t duration;
 606         char *duration_text;
 607         int retval;
 608
 609         duration_start_measure(&duration);
 610
 611         retval = find_and_run_command(cmd_ctx, cmd_ctx->commands, args, argc, 0);
 612
 613         duration_stop_measure(&duration, &duration_text);
 614
 615         float t=duration.duration.tv_sec;
 616         t+=((float)duration.duration.tv_usec / 1000000.0);
 617         command_print(cmd_ctx, "%s took %fs", args[0], t);
 618
 619         free(duration_text);
 620
 621         return retval;
 622 }