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