gdb/cli/cli-decode.c

   1 /* Handle lists of commands, their decoding and documentation, for GDB.
   2
   3    Copyright (C) 1986-2015 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "defs.h"
  19 #include "symtab.h"
  20 #include <ctype.h>
  21 #include "gdb_regex.h"
  22 #include "completer.h"
  23 #include "ui-out.h"
  24 #include "cli/cli-cmds.h"
  25 #include "cli/cli-decode.h"
  26
  27 /* Prototypes for local functions.  */
  28
  29 static void undef_cmd_error (const char *, const char *);
  30
  31 static struct cmd_list_element *delete_cmd (const char *name,
  32                                             struct cmd_list_element **list,
  33                                             struct cmd_list_element **prehook,
  34                                             struct cmd_list_element **prehookee,
  35                                             struct cmd_list_element **posthook,
  36                                             struct cmd_list_element **posthookee);
  37
  38 static struct cmd_list_element *find_cmd (const char *command,
  39                                           int len,
  40                                           struct cmd_list_element *clist,
  41                                           int ignore_help_classes,
  42                                           int *nfound);
  43
  44 static void help_all (struct ui_file *stream);
  45
  46 /* Look up a command whose 'prefixlist' is KEY.  Return the command if found,
  47    otherwise return NULL.  */
  48
  49 static struct cmd_list_element *
  50 lookup_cmd_for_prefixlist (struct cmd_list_element **key,
  51                            struct cmd_list_element *list)
  52 {
  53   struct cmd_list_element *p = NULL;
  54
  55   for (p = list; p != NULL; p = p->next)
  56     {
  57       struct cmd_list_element *q;
  58
  59       if (p->prefixlist == NULL)
  60         continue;
  61       else if (p->prefixlist == key)
  62         return p;
  63
  64       q = lookup_cmd_for_prefixlist (key, *(p->prefixlist));
  65       if (q != NULL)
  66         return q;
  67     }
  68
  69   return NULL;
  70 }
  71
  72 static void
  73 set_cmd_prefix (struct cmd_list_element *c, struct cmd_list_element **list)
  74 {
  75   struct cmd_list_element *p;
  76
  77   /* Check to see if *LIST contains any element other than C.  */
  78   for (p = *list; p != NULL; p = p->next)
  79     if (p != c)
  80       break;
  81
  82   if (p == NULL)
  83     {
  84       /* *SET_LIST only contains SET.  */
  85       p = lookup_cmd_for_prefixlist (list, setlist);
  86
  87       c->prefix = p ? (p->cmd_pointer ? p->cmd_pointer : p) : p;
  88     }
  89   else
  90     c->prefix = p->prefix;
  91 }
  92
  93 static void
  94 print_help_for_command (struct cmd_list_element *c, const char *prefix,
  95                         int recurse, struct ui_file *stream);
  96
  97 \f
  98 /* Set the callback function for the specified command.  For each both
  99    the commands callback and func() are set.  The latter set to a
 100    bounce function (unless cfunc / sfunc is NULL that is).  */
 101
 102 static void
 103 do_cfunc (struct cmd_list_element *c, char *args, int from_tty)
 104 {
 105   c->function.cfunc (args, from_tty); /* Ok.  */
 106 }
 107
 108 void
 109 set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
 110 {
 111   if (cfunc == NULL)
 112     cmd->func = NULL;
 113   else
 114     cmd->func = do_cfunc;
 115   cmd->function.cfunc = cfunc; /* Ok.  */
 116 }
 117
 118 static void
 119 do_sfunc (struct cmd_list_element *c, char *args, int from_tty)
 120 {
 121   c->function.sfunc (args, from_tty, c); /* Ok.  */
 122 }
 123
 124 void
 125 set_cmd_sfunc (struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc)
 126 {
 127   if (sfunc == NULL)
 128     cmd->func = NULL;
 129   else
 130     cmd->func = do_sfunc;
 131   cmd->function.sfunc = sfunc; /* Ok.  */
 132 }
 133
 134 int
 135 cmd_cfunc_eq (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
 136 {
 137   return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
 138 }
 139
 140 void
 141 set_cmd_context (struct cmd_list_element *cmd, void *context)
 142 {
 143   cmd->context = context;
 144 }
 145
 146 void *
 147 get_cmd_context (struct cmd_list_element *cmd)
 148 {
 149   return cmd->context;
 150 }
 151
 152 enum cmd_types
 153 cmd_type (struct cmd_list_element *cmd)
 154 {
 155   return cmd->type;
 156 }
 157
 158 void
 159 set_cmd_completer (struct cmd_list_element *cmd, completer_ftype *completer)
 160 {
 161   cmd->completer = completer; /* Ok.  */
 162 }
 163
 164 /* See definition in commands.h.  */
 165
 166 void
 167 set_cmd_completer_handle_brkchars (struct cmd_list_element *cmd,
 168                                completer_ftype_void *completer_handle_brkchars)
 169 {
 170   cmd->completer_handle_brkchars = completer_handle_brkchars;
 171 }
 172
 173 /* Add element named NAME.
 174    Space for NAME and DOC must be allocated by the caller.
 175    CLASS is the top level category into which commands are broken down
 176    for "help" purposes.
 177    FUN should be the function to execute the command;
 178    it will get a character string as argument, with leading
 179    and trailing blanks already eliminated.
 180
 181    DOC is a documentation string for the command.
 182    Its first line should be a complete sentence.
 183    It should start with ? for a command that is an abbreviation
 184    or with * for a command that most users don't need to know about.
 185
 186    Add this command to command list *LIST.
 187
 188    Returns a pointer to the added command (not necessarily the head
 189    of *LIST).  */
 190
 191 struct cmd_list_element *
 192 add_cmd (const char *name, enum command_class theclass, cmd_cfunc_ftype *fun,
 193          const char *doc, struct cmd_list_element **list)
 194 {
 195   struct cmd_list_element *c = XNEW (struct cmd_list_element);
 196   struct cmd_list_element *p, *iter;
 197
 198   /* Turn each alias of the old command into an alias of the new
 199      command.  */
 200   c->aliases = delete_cmd (name, list, &c->hook_pre, &c->hookee_pre,
 201                            &c->hook_post, &c->hookee_post);
 202   for (iter = c->aliases; iter; iter = iter->alias_chain)
 203     iter->cmd_pointer = c;
 204   if (c->hook_pre)
 205     c->hook_pre->hookee_pre = c;
 206   if (c->hookee_pre)
 207     c->hookee_pre->hook_pre = c;
 208   if (c->hook_post)
 209     c->hook_post->hookee_post = c;
 210   if (c->hookee_post)
 211     c->hookee_post->hook_post = c;
 212
 213   if (*list == NULL || strcmp ((*list)->name, name) >= 0)
 214     {
 215       c->next = *list;
 216       *list = c;
 217     }
 218   else
 219     {
 220       p = *list;
 221       while (p->next && strcmp (p->next->name, name) <= 0)
 222         {
 223           p = p->next;
 224         }
 225       c->next = p->next;
 226       p->next = c;
 227     }
 228
 229   c->name = name;
 230   c->theclass = theclass;
 231   set_cmd_cfunc (c, fun);
 232   set_cmd_context (c, NULL);
 233   c->doc = doc;
 234   c->cmd_deprecated = 0;
 235   c->deprecated_warn_user = 0;
 236   c->malloced_replacement = 0;
 237   c->doc_allocated = 0;
 238   c->replacement = NULL;
 239   c->pre_show_hook = NULL;
 240   c->hook_in = 0;
 241   c->prefixlist = NULL;
 242   c->prefixname = NULL;
 243   c->allow_unknown = 0;
 244   c->prefix = NULL;
 245   c->abbrev_flag = 0;
 246   set_cmd_completer (c, make_symbol_completion_list_fn);
 247   c->completer_handle_brkchars = NULL;
 248   c->destroyer = NULL;
 249   c->type = not_set_cmd;
 250   c->var = NULL;
 251   c->var_type = var_boolean;
 252   c->enums = NULL;
 253   c->user_commands = NULL;
 254   c->cmd_pointer = NULL;
 255   c->alias_chain = NULL;
 256
 257   return c;
 258 }
 259
 260 /* Deprecates a command CMD.
 261    REPLACEMENT is the name of the command which should be used in
 262    place of this command, or NULL if no such command exists.
 263
 264    This function does not check to see if command REPLACEMENT exists
 265    since gdb may not have gotten around to adding REPLACEMENT when
 266    this function is called.
 267
 268    Returns a pointer to the deprecated command.  */
 269
 270 struct cmd_list_element *
 271 deprecate_cmd (struct cmd_list_element *cmd, const char *replacement)
 272 {
 273   cmd->cmd_deprecated = 1;
 274   cmd->deprecated_warn_user = 1;
 275
 276   if (replacement != NULL)
 277     cmd->replacement = replacement;
 278   else
 279     cmd->replacement = NULL;
 280
 281   return cmd;
 282 }
 283
 284 struct cmd_list_element *
 285 add_alias_cmd (const char *name, const char *oldname, enum command_class theclass,
 286                int abbrev_flag, struct cmd_list_element **list)
 287 {
 288   const char *tmp;
 289   struct cmd_list_element *old;
 290   struct cmd_list_element *c;
 291
 292   tmp = oldname;
 293   old = lookup_cmd (&tmp, *list, "", 1, 1);
 294
 295   if (old == 0)
 296     {
 297       struct cmd_list_element *prehook, *prehookee, *posthook, *posthookee;
 298       struct cmd_list_element *aliases = delete_cmd (name, list,
 299                                                      &prehook, &prehookee,
 300                                                      &posthook, &posthookee);
 301
 302       /* If this happens, it means a programmer error somewhere.  */
 303       gdb_assert (!aliases && !prehook && !prehookee
 304                   && !posthook && ! posthookee);
 305       return 0;
 306     }
 307
 308   c = add_cmd (name, theclass, NULL, old->doc, list);
 309
 310   /* If OLD->DOC can be freed, we should make another copy.  */
 311   if (old->doc_allocated)
 312     {
 313       c->doc = xstrdup (old->doc);
 314       c->doc_allocated = 1;
 315     }
 316   /* NOTE: Both FUNC and all the FUNCTIONs need to be copied.  */
 317   c->func = old->func;
 318   c->function = old->function;
 319   c->prefixlist = old->prefixlist;
 320   c->prefixname = old->prefixname;
 321   c->allow_unknown = old->allow_unknown;
 322   c->abbrev_flag = abbrev_flag;
 323   c->cmd_pointer = old;
 324   c->alias_chain = old->aliases;
 325   old->aliases = c;
 326
 327   set_cmd_prefix (c, list);
 328   return c;
 329 }
 330
 331 /* Like add_cmd but adds an element for a command prefix: a name that
 332    should be followed by a subcommand to be looked up in another
 333    command list.  PREFIXLIST should be the address of the variable
 334    containing that list.  */
 335
 336 struct cmd_list_element *
 337 add_prefix_cmd (const char *name, enum command_class theclass,
 338                 cmd_cfunc_ftype *fun,
 339                 const char *doc, struct cmd_list_element **prefixlist,
 340                 const char *prefixname, int allow_unknown,
 341                 struct cmd_list_element **list)
 342 {
 343   struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
 344   struct cmd_list_element *p;
 345
 346   c->prefixlist = prefixlist;
 347   c->prefixname = prefixname;
 348   c->allow_unknown = allow_unknown;
 349
 350   if (list == &cmdlist)
 351     c->prefix = NULL;
 352   else
 353     set_cmd_prefix (c, list);
 354
 355   /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST.  */
 356   for (p = *prefixlist; p != NULL; p = p->next)
 357     p->prefix = c;
 358
 359   return c;
 360 }
 361
 362 /* Like add_prefix_cmd but sets the abbrev_flag on the new command.  */
 363
 364 struct cmd_list_element *
 365 add_abbrev_prefix_cmd (const char *name, enum command_class theclass,
 366                        cmd_cfunc_ftype *fun, const char *doc,
 367                        struct cmd_list_element **prefixlist,
 368                        const char *prefixname,
 369                        int allow_unknown, struct cmd_list_element **list)
 370 {
 371   struct cmd_list_element *c = add_cmd (name, theclass, fun, doc, list);
 372
 373   c->prefixlist = prefixlist;
 374   c->prefixname = prefixname;
 375   c->allow_unknown = allow_unknown;
 376   c->abbrev_flag = 1;
 377   return c;
 378 }
 379
 380 /* This is an empty "cfunc".  */
 381 void
 382 not_just_help_class_command (char *args, int from_tty)
 383 {
 384 }
 385
 386 /* This is an empty "sfunc".  */
 387 static void empty_sfunc (char *, int, struct cmd_list_element *);
 388
 389 static void
 390 empty_sfunc (char *args, int from_tty, struct cmd_list_element *c)
 391 {
 392 }
 393
 394 /* Add element named NAME to command list LIST (the list for set/show
 395    or some sublist thereof).
 396    TYPE is set_cmd or show_cmd.
 397    CLASS is as in add_cmd.
 398    VAR_TYPE is the kind of thing we are setting.
 399    VAR is address of the variable being controlled by this command.
 400    DOC is the documentation string.  */
 401
 402 static struct cmd_list_element *
 403 add_set_or_show_cmd (const char *name,
 404                      enum cmd_types type,
 405                      enum command_class theclass,
 406                      var_types var_type,
 407                      void *var,
 408                      const char *doc,
 409                      struct cmd_list_element **list)
 410 {
 411   struct cmd_list_element *c = add_cmd (name, theclass, NULL, doc, list);
 412
 413   gdb_assert (type == set_cmd || type == show_cmd);
 414   c->type = type;
 415   c->var_type = var_type;
 416   c->var = var;
 417   /* This needs to be something besides NULL so that this isn't
 418      treated as a help class.  */
 419   set_cmd_sfunc (c, empty_sfunc);
 420   return c;
 421 }
 422
 423 /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
 424    CLASS is as in add_cmd.  VAR_TYPE is the kind of thing we are
 425    setting.  VAR is address of the variable being controlled by this
 426    command.  SET_FUNC and SHOW_FUNC are the callback functions (if
 427    non-NULL).  SET_DOC, SHOW_DOC and HELP_DOC are the documentation
 428    strings.  PRINT the format string to print the value.  SET_RESULT
 429    and SHOW_RESULT, if not NULL, are set to the resulting command
 430    structures.  */
 431
 432 static void
 433 add_setshow_cmd_full (const char *name,
 434                       enum command_class theclass,
 435                       var_types var_type, void *var,
 436                       const char *set_doc, const char *show_doc,
 437                       const char *help_doc,
 438                       cmd_sfunc_ftype *set_func,
 439                       show_value_ftype *show_func,
 440                       struct cmd_list_element **set_list,
 441                       struct cmd_list_element **show_list,
 442                       struct cmd_list_element **set_result,
 443                       struct cmd_list_element **show_result)
 444 {
 445   struct cmd_list_element *set;
 446   struct cmd_list_element *show;
 447   char *full_set_doc;
 448   char *full_show_doc;
 449
 450   if (help_doc != NULL)
 451     {
 452       full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc);
 453       full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc);
 454     }
 455   else
 456     {
 457       full_set_doc = xstrdup (set_doc);
 458       full_show_doc = xstrdup (show_doc);
 459     }
 460   set = add_set_or_show_cmd (name, set_cmd, theclass, var_type, var,
 461                              full_set_doc, set_list);
 462   set->doc_allocated = 1;
 463
 464   if (set_func != NULL)
 465     set_cmd_sfunc (set, set_func);
 466
 467   set_cmd_prefix (set, set_list);
 468
 469   show = add_set_or_show_cmd (name, show_cmd, theclass, var_type, var,
 470                               full_show_doc, show_list);
 471   show->doc_allocated = 1;
 472   show->show_value_func = show_func;
 473
 474   if (set_result != NULL)
 475     *set_result = set;
 476   if (show_result != NULL)
 477     *show_result = show;
 478 }
 479
 480 /* Add element named NAME to command list LIST (the list for set or
 481    some sublist thereof).  CLASS is as in add_cmd.  ENUMLIST is a list
 482    of strings which may follow NAME.  VAR is address of the variable
 483    which will contain the matching string (from ENUMLIST).  */
 484
 485 void
 486 add_setshow_enum_cmd (const char *name,
 487                       enum command_class theclass,
 488                       const char *const *enumlist,
 489                       const char **var,
 490                       const char *set_doc,
 491                       const char *show_doc,
 492                       const char *help_doc,
 493                       cmd_sfunc_ftype *set_func,
 494                       show_value_ftype *show_func,
 495                       struct cmd_list_element **set_list,
 496                       struct cmd_list_element **show_list)
 497 {
 498   struct cmd_list_element *c;
 499
 500   add_setshow_cmd_full (name, theclass, var_enum, var,
 501                         set_doc, show_doc, help_doc,
 502                         set_func, show_func,
 503                         set_list, show_list,
 504                         &c, NULL);
 505   c->enums = enumlist;
 506 }
 507
 508 const char * const auto_boolean_enums[] = { "on", "off", "auto", NULL };
 509
 510 /* Add an auto-boolean command named NAME to both the set and show
 511    command list lists.  CLASS is as in add_cmd.  VAR is address of the
 512    variable which will contain the value.  DOC is the documentation
 513    string.  FUNC is the corresponding callback.  */
 514 void
 515 add_setshow_auto_boolean_cmd (const char *name,
 516                               enum command_class theclass,
 517                               enum auto_boolean *var,
 518                               const char *set_doc, const char *show_doc,
 519                               const char *help_doc,
 520                               cmd_sfunc_ftype *set_func,
 521                               show_value_ftype *show_func,
 522                               struct cmd_list_element **set_list,
 523                               struct cmd_list_element **show_list)
 524 {
 525   struct cmd_list_element *c;
 526
 527   add_setshow_cmd_full (name, theclass, var_auto_boolean, var,
 528                         set_doc, show_doc, help_doc,
 529                         set_func, show_func,
 530                         set_list, show_list,
 531                         &c, NULL);
 532   c->enums = auto_boolean_enums;
 533 }
 534
 535 /* Add element named NAME to both the set and show command LISTs (the
 536    list for set/show or some sublist thereof).  CLASS is as in
 537    add_cmd.  VAR is address of the variable which will contain the
 538    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
 539 void
 540 add_setshow_boolean_cmd (const char *name, enum command_class theclass, int *var,
 541                          const char *set_doc, const char *show_doc,
 542                          const char *help_doc,
 543                          cmd_sfunc_ftype *set_func,
 544                          show_value_ftype *show_func,
 545                          struct cmd_list_element **set_list,
 546                          struct cmd_list_element **show_list)
 547 {
 548   static const char *boolean_enums[] = { "on", "off", NULL };
 549   struct cmd_list_element *c;
 550
 551   add_setshow_cmd_full (name, theclass, var_boolean, var,
 552                         set_doc, show_doc, help_doc,
 553                         set_func, show_func,
 554                         set_list, show_list,
 555                         &c, NULL);
 556   c->enums = boolean_enums;
 557 }
 558
 559 /* Add element named NAME to both the set and show command LISTs (the
 560    list for set/show or some sublist thereof).  */
 561 void
 562 add_setshow_filename_cmd (const char *name, enum command_class theclass,
 563                           char **var,
 564                           const char *set_doc, const char *show_doc,
 565                           const char *help_doc,
 566                           cmd_sfunc_ftype *set_func,
 567                           show_value_ftype *show_func,
 568                           struct cmd_list_element **set_list,
 569                           struct cmd_list_element **show_list)
 570 {
 571   struct cmd_list_element *set_result;
 572
 573   add_setshow_cmd_full (name, theclass, var_filename, var,
 574                         set_doc, show_doc, help_doc,
 575                         set_func, show_func,
 576                         set_list, show_list,
 577                         &set_result, NULL);
 578   set_cmd_completer (set_result, filename_completer);
 579 }
 580
 581 /* Add element named NAME to both the set and show command LISTs (the
 582    list for set/show or some sublist thereof).  */
 583 void
 584 add_setshow_string_cmd (const char *name, enum command_class theclass,
 585                         char **var,
 586                         const char *set_doc, const char *show_doc,
 587                         const char *help_doc,
 588                         cmd_sfunc_ftype *set_func,
 589                         show_value_ftype *show_func,
 590                         struct cmd_list_element **set_list,
 591                         struct cmd_list_element **show_list)
 592 {
 593   add_setshow_cmd_full (name, theclass, var_string, var,
 594                         set_doc, show_doc, help_doc,
 595                         set_func, show_func,
 596                         set_list, show_list,
 597                         NULL, NULL);
 598 }
 599
 600 /* Add element named NAME to both the set and show command LISTs (the
 601    list for set/show or some sublist thereof).  */
 602 struct cmd_list_element *
 603 add_setshow_string_noescape_cmd (const char *name, enum command_class theclass,
 604                                  char **var,
 605                                  const char *set_doc, const char *show_doc,
 606                                  const char *help_doc,
 607                                  cmd_sfunc_ftype *set_func,
 608                                  show_value_ftype *show_func,
 609                                  struct cmd_list_element **set_list,
 610                                  struct cmd_list_element **show_list)
 611 {
 612   struct cmd_list_element *set_cmd;
 613
 614   add_setshow_cmd_full (name, theclass, var_string_noescape, var,
 615                         set_doc, show_doc, help_doc,
 616                         set_func, show_func,
 617                         set_list, show_list,
 618                         &set_cmd, NULL);
 619   return set_cmd;
 620 }
 621
 622 /* Add element named NAME to both the set and show command LISTs (the
 623    list for set/show or some sublist thereof).  */
 624 void
 625 add_setshow_optional_filename_cmd (const char *name, enum command_class theclass,
 626                                    char **var,
 627                                    const char *set_doc, const char *show_doc,
 628                                    const char *help_doc,
 629                                    cmd_sfunc_ftype *set_func,
 630                                    show_value_ftype *show_func,
 631                                    struct cmd_list_element **set_list,
 632                                    struct cmd_list_element **show_list)
 633 {
 634   struct cmd_list_element *set_result;
 635
 636   add_setshow_cmd_full (name, theclass, var_optional_filename, var,
 637                         set_doc, show_doc, help_doc,
 638                         set_func, show_func,
 639                         set_list, show_list,
 640                         &set_result, NULL);
 641
 642   set_cmd_completer (set_result, filename_completer);
 643
 644 }
 645
 646 /* Completes on literal "unlimited".  Used by integer commands that
 647    support a special "unlimited" value.  */
 648
 649 static VEC (char_ptr) *
 650 integer_unlimited_completer (struct cmd_list_element *ignore,
 651                              const char *text, const char *word)
 652 {
 653   static const char * const keywords[] =
 654     {
 655       "unlimited",
 656       NULL,
 657     };
 658
 659   return complete_on_enum (keywords, text, word);
 660 }
 661
 662 /* Add element named NAME to both the set and show command LISTs (the
 663    list for set/show or some sublist thereof).  CLASS is as in
 664    add_cmd.  VAR is address of the variable which will contain the
 665    value.  SET_DOC and SHOW_DOC are the documentation strings.  This
 666    function is only used in Python API.  Please don't use it elsewhere.  */
 667 void
 668 add_setshow_integer_cmd (const char *name, enum command_class theclass,
 669                          int *var,
 670                          const char *set_doc, const char *show_doc,
 671                          const char *help_doc,
 672                          cmd_sfunc_ftype *set_func,
 673                          show_value_ftype *show_func,
 674                          struct cmd_list_element **set_list,
 675                          struct cmd_list_element **show_list)
 676 {
 677   struct cmd_list_element *set;
 678
 679   add_setshow_cmd_full (name, theclass, var_integer, var,
 680                         set_doc, show_doc, help_doc,
 681                         set_func, show_func,
 682                         set_list, show_list,
 683                         &set, NULL);
 684
 685   set_cmd_completer (set, integer_unlimited_completer);
 686 }
 687
 688 /* Add element named NAME to both the set and show command LISTs (the
 689    list for set/show or some sublist thereof).  CLASS is as in
 690    add_cmd.  VAR is address of the variable which will contain the
 691    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
 692 void
 693 add_setshow_uinteger_cmd (const char *name, enum command_class theclass,
 694                           unsigned int *var,
 695                           const char *set_doc, const char *show_doc,
 696                           const char *help_doc,
 697                           cmd_sfunc_ftype *set_func,
 698                           show_value_ftype *show_func,
 699                           struct cmd_list_element **set_list,
 700                           struct cmd_list_element **show_list)
 701 {
 702   struct cmd_list_element *set;
 703
 704   add_setshow_cmd_full (name, theclass, var_uinteger, var,
 705                         set_doc, show_doc, help_doc,
 706                         set_func, show_func,
 707                         set_list, show_list,
 708                         &set, NULL);
 709
 710   set_cmd_completer (set, integer_unlimited_completer);
 711 }
 712
 713 /* Add element named NAME to both the set and show command LISTs (the
 714    list for set/show or some sublist thereof).  CLASS is as in
 715    add_cmd.  VAR is address of the variable which will contain the
 716    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
 717 void
 718 add_setshow_zinteger_cmd (const char *name, enum command_class theclass,
 719                           int *var,
 720                           const char *set_doc, const char *show_doc,
 721                           const char *help_doc,
 722                           cmd_sfunc_ftype *set_func,
 723                           show_value_ftype *show_func,
 724                           struct cmd_list_element **set_list,
 725                           struct cmd_list_element **show_list)
 726 {
 727   add_setshow_cmd_full (name, theclass, var_zinteger, var,
 728                         set_doc, show_doc, help_doc,
 729                         set_func, show_func,
 730                         set_list, show_list,
 731                         NULL, NULL);
 732 }
 733
 734 void
 735 add_setshow_zuinteger_unlimited_cmd (const char *name,
 736                                      enum command_class theclass,
 737                                      int *var,
 738                                      const char *set_doc,
 739                                      const char *show_doc,
 740                                      const char *help_doc,
 741                                      cmd_sfunc_ftype *set_func,
 742                                      show_value_ftype *show_func,
 743                                      struct cmd_list_element **set_list,
 744                                      struct cmd_list_element **show_list)
 745 {
 746   struct cmd_list_element *set;
 747
 748   add_setshow_cmd_full (name, theclass, var_zuinteger_unlimited, var,
 749                         set_doc, show_doc, help_doc,
 750                         set_func, show_func,
 751                         set_list, show_list,
 752                         &set, NULL);
 753
 754   set_cmd_completer (set, integer_unlimited_completer);
 755 }
 756
 757 /* Add element named NAME to both the set and show command LISTs (the
 758    list for set/show or some sublist thereof).  CLASS is as in
 759    add_cmd.  VAR is address of the variable which will contain the
 760    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
 761 void
 762 add_setshow_zuinteger_cmd (const char *name, enum command_class theclass,
 763                            unsigned int *var,
 764                            const char *set_doc, const char *show_doc,
 765                            const char *help_doc,
 766                            cmd_sfunc_ftype *set_func,
 767                            show_value_ftype *show_func,
 768                            struct cmd_list_element **set_list,
 769                            struct cmd_list_element **show_list)
 770 {
 771   add_setshow_cmd_full (name, theclass, var_zuinteger, var,
 772                         set_doc, show_doc, help_doc,
 773                         set_func, show_func,
 774                         set_list, show_list,
 775                         NULL, NULL);
 776 }
 777
 778 /* Remove the command named NAME from the command list.  Return the
 779    list commands which were aliased to the deleted command.  If the
 780    command had no aliases, return NULL.  The various *HOOKs are set to
 781    the pre- and post-hook commands for the deleted command.  If the
 782    command does not have a hook, the corresponding out parameter is
 783    set to NULL.  */
 784
 785 static struct cmd_list_element *
 786 delete_cmd (const char *name, struct cmd_list_element **list,
 787             struct cmd_list_element **prehook,
 788             struct cmd_list_element **prehookee,
 789             struct cmd_list_element **posthook,
 790             struct cmd_list_element **posthookee)
 791 {
 792   struct cmd_list_element *iter;
 793   struct cmd_list_element **previous_chain_ptr;
 794   struct cmd_list_element *aliases = NULL;
 795
 796   *prehook = NULL;
 797   *prehookee = NULL;
 798   *posthook = NULL;
 799   *posthookee = NULL;
 800   previous_chain_ptr = list;
 801
 802   for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr)
 803     {
 804       if (strcmp (iter->name, name) == 0)
 805         {
 806           if (iter->destroyer)
 807             iter->destroyer (iter, iter->context);
 808           if (iter->hookee_pre)
 809             iter->hookee_pre->hook_pre = 0;
 810           *prehook = iter->hook_pre;
 811           *prehookee = iter->hookee_pre;
 812           if (iter->hookee_post)
 813             iter->hookee_post->hook_post = 0;
 814           if (iter->doc && iter->doc_allocated)
 815             xfree ((char *) iter->doc);
 816           *posthook = iter->hook_post;
 817           *posthookee = iter->hookee_post;
 818
 819           /* Update the link.  */
 820           *previous_chain_ptr = iter->next;
 821
 822           aliases = iter->aliases;
 823
 824           /* If this command was an alias, remove it from the list of
 825              aliases.  */
 826           if (iter->cmd_pointer)
 827             {
 828               struct cmd_list_element **prevp = &iter->cmd_pointer->aliases;
 829               struct cmd_list_element *a = *prevp;
 830
 831               while (a != iter)
 832                 {
 833                   prevp = &a->alias_chain;
 834                   a = *prevp;
 835                 }
 836               *prevp = iter->alias_chain;
 837             }
 838
 839           xfree (iter);
 840
 841           /* We won't see another command with the same name.  */
 842           break;
 843         }
 844       else
 845         previous_chain_ptr = &iter->next;
 846     }
 847
 848   return aliases;
 849 }
 850 \f
 851 /* Shorthands to the commands above.  */
 852
 853 /* Add an element to the list of info subcommands.  */
 854
 855 struct cmd_list_element *
 856 add_info (const char *name, cmd_cfunc_ftype *fun, const char *doc)
 857 {
 858   return add_cmd (name, class_info, fun, doc, &infolist);
 859 }
 860
 861 /* Add an alias to the list of info subcommands.  */
 862
 863 struct cmd_list_element *
 864 add_info_alias (const char *name, const char *oldname, int abbrev_flag)
 865 {
 866   return add_alias_cmd (name, oldname, class_run, abbrev_flag, &infolist);
 867 }
 868
 869 /* Add an element to the list of commands.  */
 870
 871 struct cmd_list_element *
 872 add_com (const char *name, enum command_class theclass, cmd_cfunc_ftype *fun,
 873          const char *doc)
 874 {
 875   return add_cmd (name, theclass, fun, doc, &cmdlist);
 876 }
 877
 878 /* Add an alias or abbreviation command to the list of commands.  */
 879
 880 struct cmd_list_element *
 881 add_com_alias (const char *name, const char *oldname, enum command_class theclass,
 882                int abbrev_flag)
 883 {
 884   return add_alias_cmd (name, oldname, theclass, abbrev_flag, &cmdlist);
 885 }
 886 \f
 887 /* Recursively walk the commandlist structures, and print out the
 888    documentation of commands that match our regex in either their
 889    name, or their documentation.
 890 */
 891 void
 892 apropos_cmd (struct ui_file *stream,
 893              struct cmd_list_element *commandlist,
 894              struct re_pattern_buffer *regex, const char *prefix)
 895 {
 896   struct cmd_list_element *c;
 897   int returnvalue;
 898
 899   /* Walk through the commands.  */
 900   for (c=commandlist;c;c=c->next)
 901     {
 902       returnvalue = -1; /* Needed to avoid double printing.  */
 903       if (c->name != NULL)
 904         {
 905           /* Try to match against the name.  */
 906           returnvalue = re_search (regex, c->name, strlen(c->name),
 907                                    0, strlen (c->name), NULL);
 908           if (returnvalue >= 0)
 909             {
 910               print_help_for_command (c, prefix,
 911                                       0 /* don't recurse */, stream);
 912             }
 913         }
 914       if (c->doc != NULL && returnvalue < 0)
 915         {
 916           /* Try to match against documentation.  */
 917           if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
 918             {
 919               print_help_for_command (c, prefix,
 920                                       0 /* don't recurse */, stream);
 921             }
 922         }
 923       /* Check if this command has subcommands and is not an
 924          abbreviation.  We skip listing subcommands of abbreviations
 925          in order to avoid duplicates in the output.  */
 926       if (c->prefixlist != NULL && !c->abbrev_flag)
 927         {
 928           /* Recursively call ourselves on the subcommand list,
 929              passing the right prefix in.  */
 930           apropos_cmd (stream,*c->prefixlist,regex,c->prefixname);
 931         }
 932     }
 933 }
 934
 935 /* This command really has to deal with two things:
 936    1) I want documentation on *this string* (usually called by
 937       "help commandname").
 938
 939    2) I want documentation on *this list* (usually called by giving a
 940       command that requires subcommands.  Also called by saying just
 941       "help".)
 942
 943    I am going to split this into two seperate comamnds, help_cmd and
 944    help_list.  */
 945
 946 void
 947 help_cmd (const char *command, struct ui_file *stream)
 948 {
 949   struct cmd_list_element *c;
 950
 951   if (!command)
 952     {
 953       help_list (cmdlist, "", all_classes, stream);
 954       return;
 955     }
 956
 957   if (strcmp (command, "all") == 0)
 958     {
 959       help_all (stream);
 960       return;
 961     }
 962
 963   c = lookup_cmd (&command, cmdlist, "", 0, 0);
 964
 965   if (c == 0)
 966     return;
 967
 968   /* There are three cases here.
 969      If c->prefixlist is nonzero, we have a prefix command.
 970      Print its documentation, then list its subcommands.
 971
 972      If c->func is non NULL, we really have a command.  Print its
 973      documentation and return.
 974
 975      If c->func is NULL, we have a class name.  Print its
 976      documentation (as if it were a command) and then set class to the
 977      number of this class so that the commands in the class will be
 978      listed.  */
 979
 980   fputs_filtered (c->doc, stream);
 981   fputs_filtered ("\n", stream);
 982
 983   if (c->prefixlist == 0 && c->func != NULL)
 984     return;
 985   fprintf_filtered (stream, "\n");
 986
 987   /* If this is a prefix command, print it's subcommands.  */
 988   if (c->prefixlist)
 989     help_list (*c->prefixlist, c->prefixname, all_commands, stream);
 990
 991   /* If this is a class name, print all of the commands in the class.  */
 992   if (c->func == NULL)
 993     help_list (cmdlist, "", c->theclass, stream);
 994
 995   if (c->hook_pre || c->hook_post)
 996     fprintf_filtered (stream,
 997                       "\nThis command has a hook (or hooks) defined:\n");
 998
 999   if (c->hook_pre)
1000     fprintf_filtered (stream,
1001                       "\tThis command is run after  : %s (pre hook)\n",
1002                     c->hook_pre->name);
1003   if (c->hook_post)
1004     fprintf_filtered (stream,
1005                       "\tThis command is run before : %s (post hook)\n",
1006                     c->hook_post->name);
1007 }
1008
1009 /*
1010  * Get a specific kind of help on a command list.
1011  *
1012  * LIST is the list.
1013  * CMDTYPE is the prefix to use in the title string.
1014  * CLASS is the class with which to list the nodes of this list (see
1015  * documentation for help_cmd_list below),  As usual, ALL_COMMANDS for
1016  * everything, ALL_CLASSES for just classes, and non-negative for only things
1017  * in a specific class.
1018  * and STREAM is the output stream on which to print things.
1019  * If you call this routine with a class >= 0, it recurses.
1020  */
1021 void
1022 help_list (struct cmd_list_element *list, const char *cmdtype,
1023            enum command_class theclass, struct ui_file *stream)
1024 {
1025   int len;
1026   char *cmdtype1, *cmdtype2;
1027
1028   /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
1029    */
1030   len = strlen (cmdtype);
1031   cmdtype1 = (char *) alloca (len + 1);
1032   cmdtype1[0] = 0;
1033   cmdtype2 = (char *) alloca (len + 4);
1034   cmdtype2[0] = 0;
1035   if (len)
1036     {
1037       cmdtype1[0] = ' ';
1038       strncpy (cmdtype1 + 1, cmdtype, len - 1);
1039       cmdtype1[len] = 0;
1040       strncpy (cmdtype2, cmdtype, len - 1);
1041       strcpy (cmdtype2 + len - 1, " sub");
1042     }
1043
1044   if (theclass == all_classes)
1045     fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
1046   else
1047     fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
1048
1049   help_cmd_list (list, theclass, cmdtype, (int) theclass >= 0, stream);
1050
1051   if (theclass == all_classes)
1052     {
1053       fprintf_filtered (stream, "\n\
1054 Type \"help%s\" followed by a class name for a list of commands in ",
1055                         cmdtype1);
1056       wrap_here ("");
1057       fprintf_filtered (stream, "that class.");
1058
1059       fprintf_filtered (stream, "\n\
1060 Type \"help all\" for the list of all commands.");
1061     }
1062
1063   fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
1064                     cmdtype1, cmdtype2);
1065   wrap_here ("");
1066   fputs_filtered ("for ", stream);
1067   wrap_here ("");
1068   fputs_filtered ("full ", stream);
1069   wrap_here ("");
1070   fputs_filtered ("documentation.\n", stream);
1071   fputs_filtered ("Type \"apropos word\" to search "
1072                   "for commands related to \"word\".\n", stream);
1073   fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
1074                   stream);
1075 }
1076
1077 static void
1078 help_all (struct ui_file *stream)
1079 {
1080   struct cmd_list_element *c;
1081   int seen_unclassified = 0;
1082
1083   for (c = cmdlist; c; c = c->next)
1084     {
1085       if (c->abbrev_flag)
1086         continue;
1087       /* If this is a class name, print all of the commands in the
1088          class.  */
1089
1090       if (c->func == NULL)
1091         {
1092           fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
1093           help_cmd_list (cmdlist, c->theclass, "", 1, stream);
1094         }
1095     }
1096
1097   /* While it's expected that all commands are in some class,
1098      as a safety measure, we'll print commands outside of any
1099      class at the end.  */
1100
1101   for (c = cmdlist; c; c = c->next)
1102     {
1103       if (c->abbrev_flag)
1104         continue;
1105
1106       if (c->theclass == no_class)
1107         {
1108           if (!seen_unclassified)
1109             {
1110               fprintf_filtered (stream, "\nUnclassified commands\n\n");
1111               seen_unclassified = 1;
1112             }
1113           print_help_for_command (c, "", 1, stream);
1114         }
1115     }
1116
1117 }
1118
1119 /* Print only the first line of STR on STREAM.  */
1120 void
1121 print_doc_line (struct ui_file *stream, const char *str)
1122 {
1123   static char *line_buffer = 0;
1124   static int line_size;
1125   const char *p;
1126
1127   if (!line_buffer)
1128     {
1129       line_size = 80;
1130       line_buffer = (char *) xmalloc (line_size);
1131     }
1132
1133   /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
1134      like '.gdbinit'.  */
1135   p = str;
1136   while (*p && *p != '\n'
1137          && ((*p != '.' && *p != ',') || (p[1] && !isspace (p[1]))))
1138     p++;
1139   if (p - str > line_size - 1)
1140     {
1141       line_size = p - str + 1;
1142       xfree (line_buffer);
1143       line_buffer = (char *) xmalloc (line_size);
1144     }
1145   strncpy (line_buffer, str, p - str);
1146   line_buffer[p - str] = '\0';
1147   if (islower (line_buffer[0]))
1148     line_buffer[0] = toupper (line_buffer[0]);
1149   fputs_filtered (line_buffer, stream);
1150 }
1151
1152 /* Print one-line help for command C.
1153    If RECURSE is non-zero, also print one-line descriptions
1154    of all prefixed subcommands.  */
1155 static void
1156 print_help_for_command (struct cmd_list_element *c, const char *prefix,
1157                         int recurse, struct ui_file *stream)
1158 {
1159   fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
1160   print_doc_line (stream, c->doc);
1161   fputs_filtered ("\n", stream);
1162
1163   if (recurse
1164       && c->prefixlist != 0
1165       && c->abbrev_flag == 0)
1166     /* Subcommands of a prefix command typically have 'all_commands'
1167        as class.  If we pass CLASS to recursive invocation,
1168        most often we won't see anything.  */
1169     help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
1170 }
1171
1172 /*
1173  * Implement a help command on command list LIST.
1174  * RECURSE should be non-zero if this should be done recursively on
1175  * all sublists of LIST.
1176  * PREFIX is the prefix to print before each command name.
1177  * STREAM is the stream upon which the output should be written.
1178  * CLASS should be:
1179  *      A non-negative class number to list only commands in that
1180  * class.
1181  *      ALL_COMMANDS to list all commands in list.
1182  *      ALL_CLASSES  to list all classes in list.
1183  *
1184  *   Note that RECURSE will be active on *all* sublists, not just the
1185  * ones selected by the criteria above (ie. the selection mechanism
1186  * is at the low level, not the high-level).
1187  */
1188 void
1189 help_cmd_list (struct cmd_list_element *list, enum command_class theclass,
1190                const char *prefix, int recurse, struct ui_file *stream)
1191 {
1192   struct cmd_list_element *c;
1193
1194   for (c = list; c; c = c->next)
1195     {
1196       if (c->abbrev_flag == 0
1197           && (theclass == all_commands
1198               || (theclass == all_classes && c->func == NULL)
1199               || (theclass == c->theclass && c->func != NULL)))
1200         {
1201           print_help_for_command (c, prefix, recurse, stream);
1202         }
1203       else if (c->abbrev_flag == 0 && recurse
1204                && theclass == class_user && c->prefixlist != NULL)
1205         /* User-defined commands may be subcommands.  */
1206         help_cmd_list (*c->prefixlist, theclass, c->prefixname,
1207                        recurse, stream);
1208     }
1209 }
1210 \f
1211
1212 /* Search the input clist for 'command'.  Return the command if
1213    found (or NULL if not), and return the number of commands
1214    found in nfound.  */
1215
1216 static struct cmd_list_element *
1217 find_cmd (const char *command, int len, struct cmd_list_element *clist,
1218           int ignore_help_classes, int *nfound)
1219 {
1220   struct cmd_list_element *found, *c;
1221
1222   found = NULL;
1223   *nfound = 0;
1224   for (c = clist; c; c = c->next)
1225     if (!strncmp (command, c->name, len)
1226         && (!ignore_help_classes || c->func))
1227       {
1228         found = c;
1229         (*nfound)++;
1230         if (c->name[len] == '\0')
1231           {
1232             *nfound = 1;
1233             break;
1234           }
1235       }
1236   return found;
1237 }
1238
1239 static int
1240 find_command_name_length (const char *text)
1241 {
1242   const char *p = text;
1243
1244   /* Treating underscores as part of command words is important
1245      so that "set args_foo()" doesn't get interpreted as
1246      "set args _foo()".  */
1247   /* Some characters are only used for TUI specific commands.
1248      However, they are always allowed for the sake of consistency.
1249
1250      Note that this is larger than the character set allowed when
1251      creating user-defined commands.  */
1252
1253   /* Recognize '!' as a single character command so that, e.g., "!ls"
1254      works as expected.  */
1255   if (*p == '!')
1256     return 1;
1257
1258   while (isalnum (*p) || *p == '-' || *p == '_'
1259          /* Characters used by TUI specific commands.  */
1260          || *p == '+' || *p == '<' || *p == '>' || *p == '$')
1261     p++;
1262
1263   return p - text;
1264 }
1265
1266 /* Return TRUE if NAME is a valid user-defined command name.
1267    This is a stricter subset of all gdb commands,
1268    see find_command_name_length.  */
1269
1270 int
1271 valid_user_defined_cmd_name_p (const char *name)
1272 {
1273   const char *p;
1274
1275   if (*name == '\0')
1276     return FALSE;
1277
1278   /* Alas "42" is a legitimate user-defined command.
1279      In the interests of not breaking anything we preserve that.  */
1280
1281   for (p = name; *p != '\0'; ++p)
1282     {
1283       if (isalnum (*p)
1284           || *p == '-'
1285           || *p == '_')
1286         ; /* Ok.  */
1287       else
1288         return FALSE;
1289     }
1290
1291   return TRUE;
1292 }
1293
1294 /* This routine takes a line of TEXT and a CLIST in which to start the
1295    lookup.  When it returns it will have incremented the text pointer past
1296    the section of text it matched, set *RESULT_LIST to point to the list in
1297    which the last word was matched, and will return a pointer to the cmd
1298    list element which the text matches.  It will return NULL if no match at
1299    all was possible.  It will return -1 (cast appropriately, ick) if ambigous
1300    matches are possible; in this case *RESULT_LIST will be set to point to
1301    the list in which there are ambiguous choices (and *TEXT will be set to
1302    the ambiguous text string).
1303
1304    If the located command was an abbreviation, this routine returns the base
1305    command of the abbreviation.
1306
1307    It does no error reporting whatsoever; control will always return
1308    to the superior routine.
1309
1310    In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1311    at the prefix_command (ie. the best match) *or* (special case) will be NULL
1312    if no prefix command was ever found.  For example, in the case of "info a",
1313    "info" matches without ambiguity, but "a" could be "args" or "address", so
1314    *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
1315    RESULT_LIST should not be interpeted as a pointer to the beginning of a
1316    list; it simply points to a specific command.  In the case of an ambiguous
1317    return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1318    "info t" can be "info types" or "info target"; upon return *TEXT has been
1319    advanced past "info ").
1320
1321    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1322    affect the operation).
1323
1324    This routine does *not* modify the text pointed to by TEXT.
1325
1326    If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1327    are actually help classes rather than commands (i.e. the function field of
1328    the struct cmd_list_element is NULL).  */
1329
1330 struct cmd_list_element *
1331 lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
1332               struct cmd_list_element **result_list, int ignore_help_classes)
1333 {
1334   char *command;
1335   int len, tmp, nfound;
1336   struct cmd_list_element *found, *c;
1337   const char *line = *text;
1338
1339   while (**text == ' ' || **text == '\t')
1340     (*text)++;
1341
1342   /* Identify the name of the command.  */
1343   len = find_command_name_length (*text);
1344
1345   /* If nothing but whitespace, return 0.  */
1346   if (len == 0)
1347     return 0;
1348
1349   /* *text and p now bracket the first command word to lookup (and
1350      it's length is len).  We copy this into a local temporary.  */
1351
1352
1353   command = (char *) alloca (len + 1);
1354   memcpy (command, *text, len);
1355   command[len] = '\0';
1356
1357   /* Look it up.  */
1358   found = 0;
1359   nfound = 0;
1360   found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1361
1362   /* We didn't find the command in the entered case, so lower case it
1363      and search again.  */
1364   if (!found || nfound == 0)
1365     {
1366       for (tmp = 0; tmp < len; tmp++)
1367         {
1368           char x = command[tmp];
1369
1370           command[tmp] = isupper (x) ? tolower (x) : x;
1371         }
1372       found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1373     }
1374
1375   /* If nothing matches, we have a simple failure.  */
1376   if (nfound == 0)
1377     return 0;
1378
1379   if (nfound > 1)
1380     {
1381       if (result_list != NULL)
1382         /* Will be modified in calling routine
1383            if we know what the prefix command is.  */
1384         *result_list = 0;
1385       return CMD_LIST_AMBIGUOUS;        /* Ambiguous.  */
1386     }
1387
1388   /* We've matched something on this list.  Move text pointer forward.  */
1389
1390   *text += len;
1391
1392   if (found->cmd_pointer)
1393     {
1394       /* We drop the alias (abbreviation) in favor of the command it
1395        is pointing to.  If the alias is deprecated, though, we need to
1396        warn the user about it before we drop it.  Note that while we
1397        are warning about the alias, we may also warn about the command
1398        itself and we will adjust the appropriate DEPRECATED_WARN_USER
1399        flags.  */
1400
1401       if (found->deprecated_warn_user)
1402         deprecated_cmd_warning (line);
1403       found = found->cmd_pointer;
1404     }
1405   /* If we found a prefix command, keep looking.  */
1406
1407   if (found->prefixlist)
1408     {
1409       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1410                         ignore_help_classes);
1411       if (!c)
1412         {
1413           /* Didn't find anything; this is as far as we got.  */
1414           if (result_list != NULL)
1415             *result_list = clist;
1416           return found;
1417         }
1418       else if (c == CMD_LIST_AMBIGUOUS)
1419         {
1420           /* We've gotten this far properly, but the next step is
1421              ambiguous.  We need to set the result list to the best
1422              we've found (if an inferior hasn't already set it).  */
1423           if (result_list != NULL)
1424             if (!*result_list)
1425               /* This used to say *result_list = *found->prefixlist.
1426                  If that was correct, need to modify the documentation
1427                  at the top of this function to clarify what is
1428                  supposed to be going on.  */
1429               *result_list = found;
1430           return c;
1431         }
1432       else
1433         {
1434           /* We matched!  */
1435           return c;
1436         }
1437     }
1438   else
1439     {
1440       if (result_list != NULL)
1441         *result_list = clist;
1442       return found;
1443     }
1444 }
1445
1446 /* All this hair to move the space to the front of cmdtype */
1447
1448 static void
1449 undef_cmd_error (const char *cmdtype, const char *q)
1450 {
1451   error (_("Undefined %scommand: \"%s\".  Try \"help%s%.*s\"."),
1452          cmdtype,
1453          q,
1454          *cmdtype ? " " : "",
1455          (int) strlen (cmdtype) - 1,
1456          cmdtype);
1457 }
1458
1459 /* Look up the contents of *LINE as a command in the command list LIST.
1460    LIST is a chain of struct cmd_list_element's.
1461    If it is found, return the struct cmd_list_element for that command
1462    and update *LINE to point after the command name, at the first argument.
1463    If not found, call error if ALLOW_UNKNOWN is zero
1464    otherwise (or if error returns) return zero.
1465    Call error if specified command is ambiguous,
1466    unless ALLOW_UNKNOWN is negative.
1467    CMDTYPE precedes the word "command" in the error message.
1468
1469    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1470    elements which are actually help classes rather than commands (i.e.
1471    the function field of the struct cmd_list_element is 0).  */
1472
1473 struct cmd_list_element *
1474 lookup_cmd (const char **line, struct cmd_list_element *list, char *cmdtype,
1475             int allow_unknown, int ignore_help_classes)
1476 {
1477   struct cmd_list_element *last_list = 0;
1478   struct cmd_list_element *c;
1479
1480   /* Note: Do not remove trailing whitespace here because this
1481      would be wrong for complete_command.  Jim Kingdon  */
1482
1483   if (!*line)
1484     error (_("Lack of needed %scommand"), cmdtype);
1485
1486   c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1487
1488   if (!c)
1489     {
1490       if (!allow_unknown)
1491         {
1492           char *q;
1493           int len = find_command_name_length (*line);
1494
1495           q = (char *) alloca (len + 1);
1496           strncpy (q, *line, len);
1497           q[len] = '\0';
1498           undef_cmd_error (cmdtype, q);
1499         }
1500       else
1501         return 0;
1502     }
1503   else if (c == CMD_LIST_AMBIGUOUS)
1504     {
1505       /* Ambigous.  Local values should be off prefixlist or called
1506          values.  */
1507       int local_allow_unknown = (last_list ? last_list->allow_unknown :
1508                                  allow_unknown);
1509       const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1510       struct cmd_list_element *local_list =
1511         (last_list ? *(last_list->prefixlist) : list);
1512
1513       if (local_allow_unknown < 0)
1514         {
1515           if (last_list)
1516             return last_list;   /* Found something.  */
1517           else
1518             return 0;           /* Found nothing.  */
1519         }
1520       else
1521         {
1522           /* Report as error.  */
1523           int amb_len;
1524           char ambbuf[100];
1525
1526           for (amb_len = 0;
1527                ((*line)[amb_len] && (*line)[amb_len] != ' '
1528                 && (*line)[amb_len] != '\t');
1529                amb_len++)
1530             ;
1531
1532           ambbuf[0] = 0;
1533           for (c = local_list; c; c = c->next)
1534             if (!strncmp (*line, c->name, amb_len))
1535               {
1536                 if (strlen (ambbuf) + strlen (c->name) + 6
1537                     < (int) sizeof ambbuf)
1538                   {
1539                     if (strlen (ambbuf))
1540                       strcat (ambbuf, ", ");
1541                     strcat (ambbuf, c->name);
1542                   }
1543                 else
1544                   {
1545                     strcat (ambbuf, "..");
1546                     break;
1547                   }
1548               }
1549           error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1550                  *line, ambbuf);
1551           return 0;             /* lint */
1552         }
1553     }
1554   else
1555     {
1556       if (c->type == set_cmd && **line != '\0' && !isspace (**line))
1557         error (_("Argument must be preceded by space."));
1558
1559       /* We've got something.  It may still not be what the caller
1560          wants (if this command *needs* a subcommand).  */
1561       while (**line == ' ' || **line == '\t')
1562         (*line)++;
1563
1564       if (c->prefixlist && **line && !c->allow_unknown)
1565         undef_cmd_error (c->prefixname, *line);
1566
1567       /* Seems to be what he wants.  Return it.  */
1568       return c;
1569     }
1570   return 0;
1571 }
1572
1573 /* We are here presumably because an alias or command in TEXT is
1574    deprecated and a warning message should be generated.  This
1575    function decodes TEXT and potentially generates a warning message
1576    as outlined below.
1577
1578    Example for 'set endian big' which has a fictitious alias 'seb'.
1579
1580    If alias wasn't used in TEXT, and the command is deprecated:
1581    "warning: 'set endian big' is deprecated."
1582
1583    If alias was used, and only the alias is deprecated:
1584    "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1585
1586    If alias was used and command is deprecated (regardless of whether
1587    the alias itself is deprecated:
1588
1589    "warning: 'set endian big' (seb) is deprecated."
1590
1591    After the message has been sent, clear the appropriate flags in the
1592    command and/or the alias so the user is no longer bothered.
1593
1594 */
1595 void
1596 deprecated_cmd_warning (const char *text)
1597 {
1598   struct cmd_list_element *alias = NULL;
1599   struct cmd_list_element *prefix_cmd = NULL;
1600   struct cmd_list_element *cmd = NULL;
1601
1602   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
1603     /* Return if text doesn't evaluate to a command.  */
1604     return;
1605
1606   if (!((alias ? alias->deprecated_warn_user : 0)
1607       || cmd->deprecated_warn_user) )
1608     /* Return if nothing is deprecated.  */
1609     return;
1610
1611   printf_filtered ("Warning:");
1612
1613   if (alias && !cmd->cmd_deprecated)
1614     printf_filtered (" '%s', an alias for the", alias->name);
1615
1616   printf_filtered (" command '");
1617
1618   if (prefix_cmd)
1619     printf_filtered ("%s", prefix_cmd->prefixname);
1620
1621   printf_filtered ("%s", cmd->name);
1622
1623   if (alias && cmd->cmd_deprecated)
1624     printf_filtered ("' (%s) is deprecated.\n", alias->name);
1625   else
1626     printf_filtered ("' is deprecated.\n");
1627
1628
1629   /* If it is only the alias that is deprecated, we want to indicate
1630      the new alias, otherwise we'll indicate the new command.  */
1631
1632   if (alias && !cmd->cmd_deprecated)
1633     {
1634       if (alias->replacement)
1635         printf_filtered ("Use '%s'.\n\n", alias->replacement);
1636       else
1637         printf_filtered ("No alternative known.\n\n");
1638      }
1639   else
1640     {
1641       if (cmd->replacement)
1642         printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1643       else
1644         printf_filtered ("No alternative known.\n\n");
1645     }
1646
1647   /* We've warned you, now we'll keep quiet.  */
1648   if (alias)
1649     alias->deprecated_warn_user = 0;
1650
1651   cmd->deprecated_warn_user = 0;
1652 }
1653
1654
1655 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1656    Return 1 on success, 0 on failure.
1657
1658    If LINE refers to an alias, *alias will point to that alias.
1659
1660    If LINE is a postfix command (i.e. one that is preceded by a prefix
1661    command) set *prefix_cmd.
1662
1663    Set *cmd to point to the command LINE indicates.
1664
1665    If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1666    exist, they are NULL when we return.
1667
1668 */
1669 int
1670 lookup_cmd_composition (const char *text,
1671                       struct cmd_list_element **alias,
1672                       struct cmd_list_element **prefix_cmd,
1673                       struct cmd_list_element **cmd)
1674 {
1675   char *command;
1676   int len, tmp, nfound;
1677   struct cmd_list_element *cur_list;
1678   struct cmd_list_element *prev_cmd;
1679
1680   *alias = NULL;
1681   *prefix_cmd = NULL;
1682   *cmd = NULL;
1683
1684   cur_list = cmdlist;
1685
1686   while (1)
1687     {
1688       /* Go through as many command lists as we need to,
1689          to find the command TEXT refers to.  */
1690
1691       prev_cmd = *cmd;
1692
1693       while (*text == ' ' || *text == '\t')
1694         (text)++;
1695
1696       /* Identify the name of the command.  */
1697       len = find_command_name_length (text);
1698
1699       /* If nothing but whitespace, return.  */
1700       if (len == 0)
1701         return 0;
1702
1703       /* Text is the start of the first command word to lookup (and
1704          it's length is len).  We copy this into a local temporary.  */
1705
1706       command = (char *) alloca (len + 1);
1707       memcpy (command, text, len);
1708       command[len] = '\0';
1709
1710       /* Look it up.  */
1711       *cmd = 0;
1712       nfound = 0;
1713       *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1714
1715       /* We didn't find the command in the entered case, so lower case
1716          it and search again.
1717       */
1718       if (!*cmd || nfound == 0)
1719         {
1720           for (tmp = 0; tmp < len; tmp++)
1721             {
1722               char x = command[tmp];
1723
1724               command[tmp] = isupper (x) ? tolower (x) : x;
1725             }
1726           *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1727         }
1728
1729       if (*cmd == CMD_LIST_AMBIGUOUS)
1730         {
1731           return 0;              /* ambiguous */
1732         }
1733
1734       if (*cmd == NULL)
1735         return 0;                /* nothing found */
1736       else
1737         {
1738           if ((*cmd)->cmd_pointer)
1739             {
1740               /* cmd was actually an alias, we note that an alias was
1741                  used (by assigning *alais) and we set *cmd.  */
1742               *alias = *cmd;
1743               *cmd = (*cmd)->cmd_pointer;
1744             }
1745           *prefix_cmd = prev_cmd;
1746         }
1747       if ((*cmd)->prefixlist)
1748         cur_list = *(*cmd)->prefixlist;
1749       else
1750         return 1;
1751
1752       text += len;
1753     }
1754 }
1755
1756 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1757
1758 /* Return a vector of char pointers which point to the different
1759    possible completions in LIST of TEXT.
1760
1761    WORD points in the same buffer as TEXT, and completions should be
1762    returned relative to this position.  For example, suppose TEXT is
1763    "foo" and we want to complete to "foobar".  If WORD is "oo", return
1764    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1765
1766 VEC (char_ptr) *
1767 complete_on_cmdlist (struct cmd_list_element *list,
1768                      const char *text, const char *word,
1769                      int ignore_help_classes)
1770 {
1771   struct cmd_list_element *ptr;
1772   VEC (char_ptr) *matchlist = NULL;
1773   int textlen = strlen (text);
1774   int pass;
1775   int saw_deprecated_match = 0;
1776
1777   /* We do one or two passes.  In the first pass, we skip deprecated
1778      commands.  If we see no matching commands in the first pass, and
1779      if we did happen to see a matching deprecated command, we do
1780      another loop to collect those.  */
1781   for (pass = 0; matchlist == 0 && pass < 2; ++pass)
1782     {
1783       for (ptr = list; ptr; ptr = ptr->next)
1784         if (!strncmp (ptr->name, text, textlen)
1785             && !ptr->abbrev_flag
1786             && (!ignore_help_classes || ptr->func
1787                 || ptr->prefixlist))
1788           {
1789             char *match;
1790
1791             if (pass == 0)
1792               {
1793                 if (ptr->cmd_deprecated)
1794                   {
1795                     saw_deprecated_match = 1;
1796                     continue;
1797                   }
1798               }
1799
1800             match = (char *) xmalloc (strlen (word) + strlen (ptr->name) + 1);
1801             if (word == text)
1802               strcpy (match, ptr->name);
1803             else if (word > text)
1804               {
1805                 /* Return some portion of ptr->name.  */
1806                 strcpy (match, ptr->name + (word - text));
1807               }
1808             else
1809               {
1810                 /* Return some of text plus ptr->name.  */
1811                 strncpy (match, word, text - word);
1812                 match[text - word] = '\0';
1813                 strcat (match, ptr->name);
1814               }
1815             VEC_safe_push (char_ptr, matchlist, match);
1816           }
1817       /* If we saw no matching deprecated commands in the first pass,
1818          just bail out.  */
1819       if (!saw_deprecated_match)
1820         break;
1821     }
1822
1823   return matchlist;
1824 }
1825
1826 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1827
1828 /* Return a vector of char pointers which point to the different
1829    possible completions in CMD of TEXT.
1830
1831    WORD points in the same buffer as TEXT, and completions should be
1832    returned relative to this position.  For example, suppose TEXT is "foo"
1833    and we want to complete to "foobar".  If WORD is "oo", return
1834    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1835
1836 VEC (char_ptr) *
1837 complete_on_enum (const char *const *enumlist,
1838                   const char *text, const char *word)
1839 {
1840   VEC (char_ptr) *matchlist = NULL;
1841   int textlen = strlen (text);
1842   int i;
1843   const char *name;
1844
1845   for (i = 0; (name = enumlist[i]) != NULL; i++)
1846     if (strncmp (name, text, textlen) == 0)
1847       {
1848         char *match;
1849
1850         match = (char *) xmalloc (strlen (word) + strlen (name) + 1);
1851         if (word == text)
1852           strcpy (match, name);
1853         else if (word > text)
1854           {
1855             /* Return some portion of name.  */
1856             strcpy (match, name + (word - text));
1857           }
1858         else
1859           {
1860             /* Return some of text plus name.  */
1861             strncpy (match, word, text - word);
1862             match[text - word] = '\0';
1863             strcat (match, name);
1864           }
1865         VEC_safe_push (char_ptr, matchlist, match);
1866       }
1867
1868   return matchlist;
1869 }
1870
1871
1872 /* Check function pointer.  */
1873 int
1874 cmd_func_p (struct cmd_list_element *cmd)
1875 {
1876   return (cmd->func != NULL);
1877 }
1878
1879
1880 /* Call the command function.  */
1881 void
1882 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
1883 {
1884   if (cmd_func_p (cmd))
1885     (*cmd->func) (cmd, args, from_tty);
1886   else
1887     error (_("Invalid command"));
1888 }
1889
1890 int
1891 cli_user_command_p (struct cmd_list_element *cmd)
1892 {
1893   return (cmd->theclass == class_user
1894           && (cmd->func == do_cfunc || cmd->func == do_sfunc));
1895 }