gdb/command.c

   1 /* Library for reading command lines and decoding commands.
   2    Copyright (C) 1986, 1989, 1990 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include <stdio.h>
  19 #include "defs.h"
  20 #include "command.h"
  21 #include "symtab.h"
  22 #include "value.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25
  26 extern char *getenv ();
  27
  28 /* Add element named NAME to command list *LIST.
  29    FUN should be the function to execute the command;
  30    it will get a character string as argument, with leading
  31    and trailing blanks already eliminated.
  32
  33    DOC is a documentation string for the command.
  34    Its first line should be a complete sentence.
  35    It should start with ? for a command that is an abbreviation
  36    or with * for a command that most users don't need to know about.  */
  37
  38 struct cmd_list_element *
  39 add_cmd (name, class, fun, doc, list)
  40      char *name;
  41      enum command_class class;
  42      void (*fun) ();
  43      char *doc;
  44      struct cmd_list_element **list;
  45 {
  46   register struct cmd_list_element *c
  47     = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
  48
  49   delete_cmd (name, list);
  50   c->next = *list;
  51   c->name = name;
  52   c->class = class;
  53   c->function = fun;
  54   c->doc = doc;
  55   c->prefixlist = 0;
  56   c->prefixname = (char *)NULL;
  57   c->allow_unknown = 0;
  58   c->abbrev_flag = 0;
  59   c->aux = 0;
  60   c->type = not_set_cmd;
  61   c->completer = make_symbol_completion_list;
  62   c->var = 0;
  63   c->var_type = var_boolean;
  64   c->user_commands = 0;
  65   *list = c;
  66   return c;
  67 }
  68
  69 /* Same as above, except that the abbrev_flag is set. */
  70
  71 struct cmd_list_element *
  72 add_abbrev_cmd (name, class, fun, doc, list)
  73      char *name;
  74      enum command_class class;
  75      void (*fun) ();
  76      char *doc;
  77      struct cmd_list_element **list;
  78 {
  79   register struct cmd_list_element *c
  80     = add_cmd (name, class, fun, doc, list);
  81
  82   c->abbrev_flag = 1;
  83   return c;
  84 }
  85
  86 struct cmd_list_element *
  87 add_alias_cmd (name, oldname, class, abbrev_flag, list)
  88      char *name;
  89      char *oldname;
  90      enum command_class class;
  91      int abbrev_flag;
  92      struct cmd_list_element **list;
  93 {
  94   /* Must do this since lookup_cmd tries to side-effect its first arg */
  95   char *copied_name;
  96   register struct cmd_list_element *old;
  97   register struct cmd_list_element *c;
  98   copied_name = (char *) alloca (strlen (oldname) + 1);
  99   strcpy (copied_name, oldname);
 100   old  = lookup_cmd (&copied_name, *list, "", 1, 1);
 101
 102   if (old == 0)
 103     {
 104       delete_cmd (name, list);
 105       return 0;
 106     }
 107
 108   c = add_cmd (name, class, old->function, old->doc, list);
 109   c->prefixlist = old->prefixlist;
 110   c->prefixname = old->prefixname;
 111   c->allow_unknown = old->allow_unknown;
 112   c->abbrev_flag = abbrev_flag;
 113   c->aux = old->aux;
 114   return c;
 115 }
 116
 117 /* Like add_cmd but adds an element for a command prefix:
 118    a name that should be followed by a subcommand to be looked up
 119    in another command list.  PREFIXLIST should be the address
 120    of the variable containing that list.  */
 121
 122 struct cmd_list_element *
 123 add_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
 124                 allow_unknown, list)
 125      char *name;
 126      enum command_class class;
 127      void (*fun) ();
 128      char *doc;
 129      struct cmd_list_element **prefixlist;
 130      char *prefixname;
 131      int allow_unknown;
 132      struct cmd_list_element **list;
 133 {
 134   register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
 135   c->prefixlist = prefixlist;
 136   c->prefixname = prefixname;
 137   c->allow_unknown = allow_unknown;
 138   return c;
 139 }
 140
 141 /* Like add_prefix_cmd butsets the abbrev_flag on the new command. */
 142
 143 struct cmd_list_element *
 144 add_abbrev_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
 145                 allow_unknown, list)
 146      char *name;
 147      enum command_class class;
 148      void (*fun) ();
 149      char *doc;
 150      struct cmd_list_element **prefixlist;
 151      char *prefixname;
 152      int allow_unknown;
 153      struct cmd_list_element **list;
 154 {
 155   register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
 156   c->prefixlist = prefixlist;
 157   c->prefixname = prefixname;
 158   c->allow_unknown = allow_unknown;
 159   c->abbrev_flag = 1;
 160   return c;
 161 }
 162
 163 /* ARGSUSED */
 164 void
 165 not_just_help_class_command (args, from_tty, c)
 166      char *args;
 167      int from_tty;
 168      struct cmd_list_element *c;
 169 {
 170 }
 171
 172 /* Add element named NAME to command list LIST (the list for set
 173    or some sublist thereof).
 174    CLASS is as in add_cmd.
 175    VAR_TYPE is the kind of thing we are setting.
 176    VAR is address of the variable being controlled by this command.
 177    DOC is the documentation string.  */
 178 struct cmd_list_element *
 179 add_set_cmd (name, class, var_type, var, doc, list)
 180      char *name;
 181      enum command_class class;
 182      var_types var_type;
 183      char *var;
 184      char *doc;
 185      struct cmd_list_element **list;
 186 {
 187   /* For set/show, we have to call do_setshow_command
 188      differently than an ordinary function (take commandlist as
 189      well as arg), so the function field isn't helpful.  However,
 190      function == NULL means that it's a help class, so set the function
 191      to not_just_help_class_command.  */
 192   struct cmd_list_element *c
 193     = add_cmd (name, class, not_just_help_class_command, doc, list);
 194
 195   c->type = set_cmd;
 196   c->var_type = var_type;
 197   c->var = var;
 198   return c;
 199 }
 200
 201 /* Where SETCMD has already been added, add the corresponding show
 202    command to LIST and return a pointer to it.  */
 203 struct cmd_list_element *
 204 add_show_from_set (setcmd, list)
 205      struct cmd_list_element *setcmd;
 206      struct cmd_list_element **list;
 207 {
 208   struct cmd_list_element *showcmd =
 209     (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
 210
 211   bcopy (setcmd, showcmd, sizeof (struct cmd_list_element));
 212   delete_cmd (showcmd->name, list);
 213   showcmd->type = show_cmd;
 214
 215   /* Replace "set " at start of docstring with "show ".  */
 216   if (setcmd->doc[0] == 'S' && setcmd->doc[1] == 'e'
 217       && setcmd->doc[2] == 't' && setcmd->doc[3] == ' ')
 218     showcmd->doc = concat ("Show ", setcmd->doc + 4, "");
 219   else
 220     fprintf (stderr, "GDB internal error: Bad docstring for set command\n");
 221
 222   showcmd->next = *list;
 223   *list = showcmd;
 224   return showcmd;
 225 }
 226
 227 /* Remove the command named NAME from the command list.  */
 228
 229 void
 230 delete_cmd (name, list)
 231      char *name;
 232      struct cmd_list_element **list;
 233 {
 234   register struct cmd_list_element *c;
 235   struct cmd_list_element *p;
 236
 237   while (*list && !strcmp ((*list)->name, name))
 238     {
 239       p = (*list)->next;
 240       free (*list);
 241       *list = p;
 242     }
 243
 244   if (*list)
 245     for (c = *list; c->next;)
 246       {
 247         if (!strcmp (c->next->name, name))
 248           {
 249             p = c->next->next;
 250             free (c->next);
 251             c->next = p;
 252           }
 253         else
 254           c = c->next;
 255       }
 256 }
 257
 258 /* This command really has to deal with two things:
 259  *     1) I want documentation on *this string* (usually called by
 260  * "help commandname").
 261  *     2) I want documentation on *this list* (usually called by
 262  * giving a command that requires subcommands.  Also called by saying
 263  * just "help".)
 264  *
 265  *   I am going to split this into two seperate comamnds, help_cmd and
 266  * help_list.
 267  */
 268
 269 void
 270 help_cmd (command, stream)
 271      char *command;
 272      FILE *stream;
 273 {
 274   struct cmd_list_element *c;
 275   extern struct cmd_list_element *cmdlist;
 276
 277   if (!command)
 278     {
 279       help_list (cmdlist, "", all_classes, stream);
 280       return;
 281     }
 282
 283   c = lookup_cmd (&command, cmdlist, "", 0, 0);
 284
 285   if (c == 0)
 286     return;
 287
 288   /* There are three cases here.
 289      If c->prefixlist is nonzero, we have a prefix command.
 290      Print its documentation, then list its subcommands.
 291
 292      If c->function is nonzero, we really have a command.
 293      Print its documentation and return.
 294
 295      If c->function is zero, we have a class name.
 296      Print its documentation (as if it were a command)
 297      and then set class to the number of this class
 298      so that the commands in the class will be listed.  */
 299
 300   fputs_filtered (c->doc, stream);
 301   fputs_filtered ("\n", stream);
 302
 303   if (c->prefixlist == 0 && c->function != 0)
 304     return;
 305   fprintf_filtered (stream, "\n");
 306
 307   /* If this is a prefix command, print it's subcommands */
 308   if (c->prefixlist)
 309     help_list (*c->prefixlist, c->prefixname, all_commands, stream);
 310
 311   /* If this is a class name, print all of the commands in the class */
 312   if (c->function == 0)
 313     help_list (cmdlist, "", c->class, stream);
 314 }
 315
 316 /*
 317  * Get a specific kind of help on a command list.
 318  *
 319  * LIST is the list.
 320  * CMDTYPE is the prefix to use in the title string.
 321  * CLASS is the class with which to list the nodes of this list (see
 322  * documentation for help_cmd_list below),  As usual, ALL_COMMANDS for
 323  * everything, ALL_CLASSES for just classes, and non-negative for only things
 324  * in a specific class.
 325  * and STREAM is the output stream on which to print things.
 326  * If you call this routine with a class >= 0, it recurses.
 327  */
 328 void
 329 help_list (list, cmdtype, class, stream)
 330      struct cmd_list_element *list;
 331      char *cmdtype;
 332      enum command_class class;
 333      FILE *stream;
 334 {
 335   int len;
 336   char *cmdtype1, *cmdtype2;
 337
 338   /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub"  */
 339   len = strlen (cmdtype);
 340   cmdtype1 = (char *) alloca (len + 1);
 341   cmdtype1[0] = 0;
 342   cmdtype2 = (char *) alloca (len + 4);
 343   cmdtype2[0] = 0;
 344   if (len)
 345     {
 346       cmdtype1[0] = ' ';
 347       strncpy (cmdtype1 + 1, cmdtype, len - 1);
 348       cmdtype1[len] = 0;
 349       strncpy (cmdtype2, cmdtype, len - 1);
 350       strcpy (cmdtype2 + len - 1, " sub");
 351     }
 352
 353   if (class == all_classes)
 354     fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
 355   else
 356     fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
 357
 358   help_cmd_list (list, class, cmdtype, (int)class >= 0, stream);
 359
 360   if (class == all_classes)
 361     fprintf_filtered (stream, "\n\
 362 Type \"help%s\" followed by a class name for a list of commands in that class.",
 363              cmdtype1);
 364
 365   fprintf_filtered (stream, "\n\
 366 Type \"help%s\" followed by %scommand name for full documentation.\n\
 367 Command name abbreviations are allowed if unambiguous.\n",
 368            cmdtype1, cmdtype2);
 369 }
 370
 371 /* Print only the first line of STR on STREAM.  */
 372 static void
 373 print_doc_line (stream, str)
 374      FILE *stream;
 375      char *str;
 376 {
 377   static char *line_buffer = 0;
 378   static int line_size;
 379   register char *p;
 380
 381   if (!line_buffer)
 382     {
 383       line_size = 80;
 384       line_buffer = (char *) xmalloc (line_size);
 385     }
 386
 387   p = str;
 388   while (*p && *p != '\n' && *p != '.' && *p != ',')
 389     p++;
 390   if (p - str > line_size - 1)
 391     {
 392       line_size = p - str + 1;
 393       free (line_buffer);
 394       line_buffer = (char *) xmalloc (line_size);
 395     }
 396   strncpy (line_buffer, str, p - str);
 397   line_buffer[p - str] = '\0';
 398   if (islower (line_buffer[0]))
 399     line_buffer[0] = toupper (line_buffer[0]);
 400   fputs_filtered (line_buffer, stream);
 401 }
 402
 403 /*
 404  * Implement a help command on command list LIST.
 405  * RECURSE should be non-zero if this should be done recursively on
 406  * all sublists of LIST.
 407  * PREFIX is the prefix to print before each command name.
 408  * STREAM is the stream upon which the output should be written.
 409  * CLASS should be:
 410  *      A non-negative class number to list only commands in that
 411  * class.
 412  *      ALL_COMMANDS to list all commands in list.
 413  *      ALL_CLASSES  to list all classes in list.
 414  *
 415  *   Note that RECURSE will be active on *all* sublists, not just the
 416  * ones seclected by the criteria above (ie. the selection mechanism
 417  * is at the low level, not the high-level).
 418  */
 419 void
 420 help_cmd_list (list, class, prefix, recurse, stream)
 421      struct cmd_list_element *list;
 422      enum command_class class;
 423      char *prefix;
 424      int recurse;
 425      FILE *stream;
 426 {
 427   register struct cmd_list_element *c;
 428
 429   for (c = list; c; c = c->next)
 430     {
 431       if (c->abbrev_flag == 0 &&
 432           (class == all_commands
 433           || (class == all_classes && c->function == 0)
 434           || (class == c->class && c->function != 0)))
 435         {
 436           fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
 437           print_doc_line (stream, c->doc);
 438           fputs_filtered ("\n", stream);
 439         }
 440       if (recurse
 441           && c->prefixlist != 0
 442           && c->abbrev_flag == 0)
 443         help_cmd_list (*c->prefixlist, class, c->prefixname, 1, stream);
 444     }
 445 }
 446 \f
 447 /* This routine takes a line of TEXT and a CLIST in which to
 448    start the lookup.  When it returns it will have incremented the text
 449    pointer past the section of text it matched, set *RESULT_LIST to
 450    the list in which the last word was matched, and will return the
 451    cmd list element which the text matches.  It will return 0 if no
 452    match at all was possible.  It will return -1 if ambigous matches are
 453    possible; in this case *RESULT_LIST will be set to the list in which
 454    there are ambiguous choices (and text will be set to the ambiguous
 455    text string).
 456
 457    It does no error reporting whatsoever; control will always return
 458    to the superior routine.
 459
 460    In the case of an ambiguous return (-1), *RESULT_LIST will be set to
 461    point at the prefix_command (ie. the best match) *or* (special
 462    case) will be 0 if no prefix command was ever found.  For example,
 463    in the case of "info a", "info" matches without ambiguity, but "a"
 464    could be "args" or "address", so *RESULT_LIST is set to
 465    the cmd_list_element for "info".  So in this case
 466    result list should not be interpeted as a pointer to the beginning
 467    of a list; it simply points to a specific command.
 468
 469    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
 470    affect the operation).
 471
 472    This routine does *not* modify the text pointed to by TEXT.
 473
 474    If IGNORE_HELP_CLASSES is nonzero, ignore any command list
 475    elements which are actually help classes rather than commands (i.e.
 476    the function field of the struct cmd_list_element is 0).  */
 477
 478 struct cmd_list_element *
 479 lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
 480      char **text;
 481      struct cmd_list_element *clist, **result_list;
 482      int ignore_help_classes;
 483 {
 484   char *p, *command;
 485   int len, tmp, nfound;
 486   struct cmd_list_element *found, *c;
 487
 488   while (**text == ' ' || **text == '\t')
 489     (*text)++;
 490
 491   /* Treating underscores as part of command words is important
 492      so that "set args_foo()" doesn't get interpreted as
 493      "set args _foo()".  */
 494   for (p = *text;
 495        *p && (isalnum(*p) || *p == '-' || *p == '_');
 496        p++)
 497     ;
 498
 499   /* If nothing but whitespace, return 0.  */
 500   if (p == *text)
 501     return 0;
 502
 503   len = p - *text;
 504
 505   /* *text and p now bracket the first command word to lookup (and
 506      it's length is len).  We copy this into a local temporary,
 507      converting to lower case as we go.  */
 508
 509   command = (char *) alloca (len + 1);
 510   for (tmp = 0; tmp < len; tmp++)
 511     {
 512       char x = (*text)[tmp];
 513       command[tmp] = (x >= 'A' && x <= 'Z') ? x - 'A' + 'a' : x;
 514     }
 515   command[len] = '\0';
 516
 517   /* Look it up.  */
 518   found = 0;
 519   nfound = 0;
 520   for (c = clist; c; c = c->next)
 521     if (!strncmp (command, c->name, len)
 522         && (!ignore_help_classes || c->function))
 523       {
 524         found = c;
 525         nfound++;
 526         if (c->name[len] == '\0')
 527           {
 528             nfound = 1;
 529             break;
 530           }
 531       }
 532
 533   /* If nothing matches, we have a simple failure.  */
 534   if (nfound == 0)
 535     return 0;
 536
 537   if (nfound > 1)
 538     {
 539       if (result_list != NULL)
 540         /* Will be modified in calling routine
 541            if we know what the prefix command is.  */
 542         *result_list = 0;
 543       return (struct cmd_list_element *) -1; /* Ambiguous.  */
 544     }
 545
 546   /* We've matched something on this list.  Move text pointer forward. */
 547
 548   *text = p;
 549   if (found->prefixlist)
 550     {
 551       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
 552                         ignore_help_classes);
 553       if (!c)
 554         {
 555           /* Didn't find anything; this is as far as we got.  */
 556           if (result_list != NULL)
 557             *result_list = clist;
 558           return found;
 559         }
 560       else if (c == (struct cmd_list_element *) -1)
 561         {
 562           /* We've gotten this far properley, but the next step
 563              is ambiguous.  We need to set the result list to the best
 564              we've found (if an inferior hasn't already set it).  */
 565           if (result_list != NULL)
 566             if (!*result_list)
 567               /* This used to say *result_list = *found->prefixlist
 568                  If that was correct, need to modify the documentation
 569                  at the top of this function to clarify what is supposed
 570                  to be going on.  */
 571               *result_list = found;
 572           return c;
 573         }
 574       else
 575         {
 576           /* We matched!  */
 577           return c;
 578         }
 579     }
 580   else
 581     {
 582       if (result_list != NULL)
 583         *result_list = clist;
 584       return found;
 585     }
 586 }
 587
 588 /* Look up the contents of *LINE as a command in the command list LIST.
 589    LIST is a chain of struct cmd_list_element's.
 590    If it is found, return the struct cmd_list_element for that command
 591    and update *LINE to point after the command name, at the first argument.
 592    If not found, call error if ALLOW_UNKNOWN is zero
 593    otherwise (or if error returns) return zero.
 594    Call error if specified command is ambiguous,
 595    unless ALLOW_UNKNOWN is negative.
 596    CMDTYPE precedes the word "command" in the error message.
 597
 598    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
 599    elements which are actually help classes rather than commands (i.e.
 600    the function field of the struct cmd_list_element is 0).  */
 601
 602 struct cmd_list_element *
 603 lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
 604      char **line;
 605      struct cmd_list_element *list;
 606      char *cmdtype;
 607      int allow_unknown;
 608      int ignore_help_classes;
 609 {
 610   struct cmd_list_element *last_list = 0;
 611   struct cmd_list_element *c =
 612     lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
 613   char *ptr = (*line) + strlen (*line) - 1;
 614
 615   /* Clear off trailing whitespace.  */
 616   while (ptr >= *line && (*ptr == ' ' || *ptr == '\t'))
 617     ptr--;
 618   *(ptr + 1) = '\0';
 619
 620   if (!c)
 621     {
 622       if (!allow_unknown)
 623         {
 624           if (!*line)
 625             error ("Lack of needed %scommand", cmdtype);
 626           else
 627             {
 628               char *p = *line, *q;
 629
 630               while (isalnum(*p) || *p == '-')
 631                 p++;
 632
 633               q = (char *) alloca (p - *line + 1);
 634               strncpy (q, *line, p - *line);
 635               q[p-*line] = '\0';
 636
 637               error ("Undefined %scommand: \"%s\".", cmdtype, q);
 638             }
 639         }
 640       else
 641         return 0;
 642     }
 643   else if (c == (struct cmd_list_element *) -1)
 644     {
 645       /* Ambigous.  Local values should be off prefixlist or called
 646          values.  */
 647       int local_allow_unknown = (last_list ? last_list->allow_unknown :
 648                                  allow_unknown);
 649       char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
 650       struct cmd_list_element *local_list =
 651         (last_list ? *(last_list->prefixlist) : list);
 652
 653       if (local_allow_unknown < 0)
 654         {
 655           if (last_list)
 656             return last_list;   /* Found something.  */
 657           else
 658             return 0;           /* Found nothing.  */
 659         }
 660       else
 661         {
 662           /* Report as error.  */
 663           int amb_len;
 664           char ambbuf[100];
 665
 666           for (amb_len = 0;
 667                ((*line)[amb_len] && (*line)[amb_len] != ' '
 668                 && (*line)[amb_len] != '\t');
 669                amb_len++)
 670             ;
 671
 672           ambbuf[0] = 0;
 673           for (c = local_list; c; c = c->next)
 674             if (!strncmp (*line, c->name, amb_len))
 675               {
 676                 if (strlen (ambbuf) + strlen (c->name) + 6 < (int)sizeof ambbuf)
 677                   {
 678                     if (strlen (ambbuf))
 679                       strcat (ambbuf, ", ");
 680                     strcat (ambbuf, c->name);
 681                   }
 682                 else
 683                   {
 684                     strcat (ambbuf, "..");
 685                     break;
 686                   }
 687               }
 688           error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype,
 689                  *line, ambbuf);
 690           return 0;             /* lint */
 691         }
 692     }
 693   else
 694     {
 695       /* We've got something.  It may still not be what the caller
 696          wants (if this command *needs* a subcommand).  */
 697       while (**line == ' ' || **line == '\t')
 698         (*line)++;
 699
 700       if (c->prefixlist && **line && !c->allow_unknown)
 701         error ("Undefined %scommand: \"%s\".", c->prefixname, *line);
 702
 703       /* Seems to be what he wants.  Return it.  */
 704       return c;
 705     }
 706   return 0;
 707 }
 708
 709 #if 0
 710 /* Look up the contents of *LINE as a command in the command list LIST.
 711    LIST is a chain of struct cmd_list_element's.
 712    If it is found, return the struct cmd_list_element for that command
 713    and update *LINE to point after the command name, at the first argument.
 714    If not found, call error if ALLOW_UNKNOWN is zero
 715    otherwise (or if error returns) return zero.
 716    Call error if specified command is ambiguous,
 717    unless ALLOW_UNKNOWN is negative.
 718    CMDTYPE precedes the word "command" in the error message.  */
 719
 720 struct cmd_list_element *
 721 lookup_cmd (line, list, cmdtype, allow_unknown)
 722      char **line;
 723      struct cmd_list_element *list;
 724      char *cmdtype;
 725      int allow_unknown;
 726 {
 727   register char *p;
 728   register struct cmd_list_element *c, *found;
 729   int nfound;
 730   char ambbuf[100];
 731   char *processed_cmd;
 732   int i, cmd_len;
 733
 734   /* Skip leading whitespace.  */
 735
 736   while (**line == ' ' || **line == '\t')
 737     (*line)++;
 738
 739   /* Clear out trailing whitespace.  */
 740
 741   p = *line + strlen (*line);
 742   while (p != *line && (p[-1] == ' ' || p[-1] == '\t'))
 743     p--;
 744   *p = 0;
 745
 746   /* Find end of command name.  */
 747
 748   p = *line;
 749   while (*p == '-'
 750          || (*p >= 'a' && *p <= 'z')
 751          || (*p >= 'A' && *p <= 'Z')
 752          || (*p >= '0' && *p <= '9'))
 753     p++;
 754
 755   /* Look up the command name.
 756      If exact match, keep that.
 757      Otherwise, take command abbreviated, if unique.  Note that (in my
 758      opinion) a null string does *not* indicate ambiguity; simply the
 759      end of the argument.  */
 760
 761   if (p == *line)
 762     {
 763       if (!allow_unknown)
 764         error ("Lack of needed %scommand", cmdtype);
 765       return 0;
 766     }
 767
 768   /* Copy over to a local buffer, converting to lowercase on the way.
 769      This is in case the command being parsed is a subcommand which
 770      doesn't match anything, and that's ok.  We want the original
 771      untouched for the routine of the original command.  */
 772
 773   processed_cmd = (char *) alloca (p - *line + 1);
 774   for (cmd_len = 0; cmd_len < p - *line; cmd_len++)
 775     {
 776       char x = (*line)[cmd_len];
 777       if (x >= 'A' && x <= 'Z')
 778         processed_cmd[cmd_len] = x - 'A' + 'a';
 779       else
 780         processed_cmd[cmd_len] = x;
 781     }
 782   processed_cmd[cmd_len] = '\0';
 783
 784   /* Check all possibilities in the current command list.  */
 785   found = 0;
 786   nfound = 0;
 787   for (c = list; c; c = c->next)
 788     {
 789       if (!strncmp (processed_cmd, c->name, cmd_len))
 790         {
 791           found = c;
 792           nfound++;
 793           if (c->name[cmd_len] == 0)
 794             {
 795               nfound = 1;
 796               break;
 797             }
 798         }
 799     }
 800
 801   /* Report error for undefined command name.  */
 802
 803   if (nfound != 1)
 804     {
 805       if (nfound > 1 && allow_unknown >= 0)
 806         {
 807           ambbuf[0] = 0;
 808           for (c = list; c; c = c->next)
 809             if (!strncmp (processed_cmd, c->name, cmd_len))
 810               {
 811                 if (strlen (ambbuf) + strlen (c->name) + 6 < sizeof ambbuf)
 812                   {
 813                     if (strlen (ambbuf))
 814                       strcat (ambbuf, ", ");
 815                     strcat (ambbuf, c->name);
 816                   }
 817                 else
 818                   {
 819                     strcat (ambbuf, "..");
 820                     break;
 821                   }
 822               }
 823           error ("Ambiguous %scommand \"%s\": %s.", cmdtype,
 824                  processed_cmd, ambbuf);
 825         }
 826       else if (!allow_unknown)
 827         error ("Undefined %scommand: \"%s\".", cmdtype, processed_cmd);
 828       return 0;
 829     }
 830
 831   /* Skip whitespace before the argument.  */
 832
 833   while (*p == ' ' || *p == '\t') p++;
 834   *line = p;
 835
 836   if (found->prefixlist && *p)
 837     {
 838       c = lookup_cmd (line, *found->prefixlist, found->prefixname,
 839                       found->allow_unknown);
 840       if (c)
 841         return c;
 842     }
 843
 844   return found;
 845 }
 846 #endif
 847
 848 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
 849
 850 /* Return a vector of char pointers which point to the different
 851    possible completions in LIST of TEXT.  */
 852
 853 char **
 854 complete_on_cmdlist (list, text)
 855      struct cmd_list_element *list;
 856      char *text;
 857 {
 858   struct cmd_list_element *ptr;
 859   char **matchlist;
 860   int sizeof_matchlist;
 861   int matches;
 862   int textlen = strlen (text);
 863
 864   sizeof_matchlist = 10;
 865   matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
 866   matches = 0;
 867
 868   for (ptr = list; ptr; ptr = ptr->next)
 869     if (!strncmp (ptr->name, text, textlen)
 870         && !ptr->abbrev_flag
 871         && (ptr->function
 872             || ptr->prefixlist))
 873       {
 874         if (matches == sizeof_matchlist)
 875           {
 876             sizeof_matchlist *= 2;
 877             matchlist = (char **) xrealloc ((char *)matchlist,
 878                                             (sizeof_matchlist
 879                                              * sizeof (char *)));
 880           }
 881
 882         matchlist[matches] = (char *)
 883           xmalloc (strlen (ptr->name) + 1);
 884         strcpy (matchlist[matches++], ptr->name);
 885       }
 886
 887   if (matches == 0)
 888     {
 889       free (matchlist);
 890       matchlist = 0;
 891     }
 892   else
 893     {
 894       matchlist = (char **) xrealloc ((char *)matchlist, ((matches + 1)
 895                                                 * sizeof (char *)));
 896       matchlist[matches] = (char *) 0;
 897     }
 898
 899   return matchlist;
 900 }
 901
 902 static int
 903 parse_binary_operation (arg)
 904      char *arg;
 905 {
 906   int length;
 907
 908   if (!arg || !*arg)
 909     return 1;
 910
 911   length = strlen (arg);
 912
 913   while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
 914     length--;
 915
 916   if (!strncmp (arg, "on", length)
 917       || !strncmp (arg, "1", length)
 918       || !strncmp (arg, "yes", length))
 919     return 1;
 920   else
 921     if (!strncmp (arg, "off", length)
 922         || !strncmp (arg, "0", length)
 923         || !strncmp (arg, "no", length))
 924       return 0;
 925     else
 926       {
 927         error ("\"on\" or \"off\" expected.");
 928         return 0;
 929       }
 930 }
 931
 932 /* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
 933    of the argument, and FROM_TTY is nonzero if this command is being entered
 934    directly by the user (i.e. these are just like any other
 935    command).  C is the command list element for the command.  */
 936 void
 937 do_setshow_command (arg, from_tty, c)
 938      char *arg;
 939      int from_tty;
 940      struct cmd_list_element *c;
 941 {
 942   if (c->type == set_cmd)
 943     {
 944       switch (c->var_type)
 945         {
 946         case var_string:
 947           {
 948             char *new;
 949             char *p;
 950             char *q;
 951             int ch;
 952
 953             if (arg == NULL)
 954               arg = "";
 955             new = (char *) xmalloc (strlen (arg) + 2);
 956             p = arg; q = new;
 957             while (ch = *p++)
 958               {
 959                 if (ch == '\\')
 960                   {
 961                     /* \ at end of argument is used after spaces
 962                        so they won't be lost.  */
 963                     if (*p == 0)
 964                       break;
 965                     ch = parse_escape (&p);
 966                     if (ch == 0)
 967                       break; /* C loses */
 968                     else if (ch > 0)
 969                       *q++ = ch;
 970                   }
 971                 else
 972                   *q++ = ch;
 973               }
 974             if (*(p - 1) != '\\')
 975               *q++ = ' ';
 976             *q++ = '\0';
 977             new = (char *) xrealloc (new, q - new);
 978             if (*(char **)c->var != NULL)
 979               free (*(char **)c->var);
 980             *(char **) c->var = new;
 981           }
 982           break;
 983         case var_string_noescape:
 984           if (arg == NULL)
 985             arg = "";
 986           if (*(char **)c->var != NULL)
 987             free (*(char **)c->var);
 988           *(char **) c->var = savestring (arg, strlen (arg));
 989           break;
 990         case var_filename:
 991           if (arg == NULL)
 992             error_no_arg ("filename to set it to.");
 993           if (*(char **)c->var != NULL)
 994             free (*(char **)c->var);
 995           *(char **)c->var = tilde_expand (arg);
 996           break;
 997         case var_boolean:
 998           *(int *) c->var = parse_binary_operation (arg);
 999           break;
1000         case var_uinteger:
1001           if (arg == NULL)
1002             error_no_arg ("integer to set it to.");
1003           *(int *) c->var = parse_and_eval_address (arg);
1004           if (*(int *) c->var == 0)
1005             *(int *) c->var = UINT_MAX;
1006           break;
1007         case var_zinteger:
1008           if (arg == NULL)
1009             error_no_arg ("integer to set it to.");
1010           *(int *) c->var = parse_and_eval_address (arg);
1011           break;
1012         default:
1013           error ("gdb internal error: bad var_type in do_setshow_command");
1014         }
1015     }
1016   else if (c->type == show_cmd)
1017     {
1018       /* Print doc minus "show" at start.  */
1019       print_doc_line (stdout, c->doc + 5);
1020
1021       fputs_filtered (" is ", stdout);
1022       wrap_here ("    ");
1023       switch (c->var_type)
1024         {
1025       case var_string:
1026         {
1027           unsigned char *p;
1028           fputs_filtered ("\"", stdout);
1029           for (p = *(unsigned char **) c->var; *p != '\0'; p++)
1030             printchar (*p, stdout, '"');
1031           fputs_filtered ("\"", stdout);
1032         }
1033         break;
1034       case var_string_noescape:
1035       case var_filename:
1036         fputs_filtered ("\"", stdout);
1037         fputs_filtered (*(char **) c->var, stdout);
1038         fputs_filtered ("\"", stdout);
1039         break;
1040       case var_boolean:
1041         fputs_filtered (*(int *) c->var ? "on" : "off", stdout);
1042         break;
1043       case var_uinteger:
1044         if (*(unsigned int *) c->var == UINT_MAX) {
1045           fputs_filtered ("unlimited", stdout);
1046           break;
1047         }
1048         /* else fall through */
1049       case var_zinteger:
1050         fprintf_filtered (stdout, "%d", *(unsigned int *) c->var);
1051         break;
1052       default:
1053         error ("gdb internal error: bad var_type in do_setshow_command");
1054       }
1055       fputs_filtered (".\n", stdout);
1056     }
1057   else
1058     error ("gdb internal error: bad cmd_type in do_setshow_command");
1059   (*c->function) (NULL, from_tty, c);
1060 }
1061
1062 /* Show all the settings in a list of show commands.  */
1063
1064 void
1065 cmd_show_list (list, from_tty, prefix)
1066      struct cmd_list_element *list;
1067      int from_tty;
1068      char *prefix;
1069 {
1070   for (; list != NULL; list = list->next) {
1071     /* If we find a prefix, run its list, prefixing our output by its
1072        prefix (with "show " skipped).  */
1073     if (list->prefixlist && !list->abbrev_flag)
1074       cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5);
1075     if (list->type == show_cmd)
1076       {
1077         fputs_filtered (prefix, stdout);
1078         fputs_filtered (list->name, stdout);
1079         fputs_filtered (":  ", stdout);
1080         do_setshow_command ((char *)NULL, from_tty, list);
1081       }
1082   }
1083 }
1084
1085 /* ARGSUSED */
1086 static void
1087 shell_escape (arg, from_tty)
1088      char *arg;
1089      int from_tty;
1090 {
1091   int rc, status, pid;
1092   char *p, *user_shell;
1093   extern char *rindex ();
1094
1095   if ((user_shell = (char *) getenv ("SHELL")) == NULL)
1096     user_shell = "/bin/sh";
1097
1098   /* Get the name of the shell for arg0 */
1099   if ((p = rindex (user_shell, '/')) == NULL)
1100     p = user_shell;
1101   else
1102     p++;                        /* Get past '/' */
1103
1104   if ((pid = fork()) == 0)
1105     {
1106       if (!arg)
1107         execl (user_shell, p, 0);
1108       else
1109         execl (user_shell, p, "-c", arg, 0);
1110
1111       fprintf (stderr, "Exec of shell failed\n");
1112       exit (0);
1113     }
1114
1115   if (pid != -1)
1116     while ((rc = wait (&status)) != pid && rc != -1)
1117       ;
1118   else
1119     error ("Fork failed");
1120 }
1121
1122 static void
1123 make_command (arg, from_tty)
1124      char *arg;
1125      int from_tty;
1126 {
1127   char *p;
1128
1129   if (arg == 0)
1130     p = "make";
1131   else
1132     {
1133       p = xmalloc (sizeof("make ") + strlen(arg));
1134       strcpy (p, "make ");
1135       strcpy (p + sizeof("make ")-1, arg);
1136     }
1137
1138   shell_escape (p, from_tty);
1139 }
1140
1141 static void
1142 user_info_1 (c, stream)
1143      struct cmd_list_element *c;
1144      FILE *stream;
1145 {
1146   register struct command_line *cmdlines;
1147
1148   cmdlines = c->user_commands;
1149   if (!cmdlines)
1150     return;
1151   fprintf_filtered (stream, "User command %s:\n", c->name);
1152   while (cmdlines)
1153     {
1154       fprintf_filtered (stream, "%s\n", cmdlines->line);
1155       cmdlines = cmdlines->next;
1156     }
1157   fputs_filtered ("\n", stream);
1158 }
1159
1160 /* ARGSUSED */
1161 static void
1162 user_info (args, from_tty)
1163      char *args;
1164      int from_tty;
1165 {
1166   struct cmd_list_element *c;
1167   extern struct cmd_list_element *cmdlist;
1168
1169   if (args)
1170     {
1171       c = lookup_cmd (&args, cmdlist, "", 0, 1);
1172       if (c->class != class_user)
1173         error ("Not a user command.");
1174       user_info_1 (c, stdout);
1175     }
1176   else
1177     {
1178       for (c = cmdlist; c; c = c->next)
1179         {
1180           if (c->class == class_user)
1181             user_info_1 (c, stdout);
1182         }
1183     }
1184 }
1185
1186 void
1187 _initialize_command ()
1188 {
1189   add_com ("shell", class_support, shell_escape,
1190            "Execute the rest of the line as a shell command.  \n\
1191 With no arguments, run an inferior shell.");
1192
1193   add_com ("make", class_support, make_command,
1194            "Run the ``make'' program using the rest of the line as arguments.");
1195
1196   add_info ("user", user_info, "Show definitions of user defined commands.\n\
1197 Argument is the name of the user defined command.\n\
1198 With no argument, show definitions of all user defined commands.");
1199 }