gdb/command.c

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