gdb/cli/cli-decode.c

   1 /* Handle lists of commands, their decoding and documentation, for GDB.
   2
   3    Copyright (C) 1986-2014 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 class, 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->class = class;
 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class, 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class,
 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, class, 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 class, cmd_cfunc_ftype *fun,
 874          const char *doc)
 875 {
 876   return add_cmd (name, class, 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 class,
 883                int abbrev_flag)
 884 {
 885   return add_alias_cmd (name, oldname, class, 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->class, 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 class, 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 (class == 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, class, cmdtype, (int) class >= 0, stream);
1051
1052   if (class == 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->class, "", 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->class == 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 class,
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           && (class == all_commands
1199               || (class == all_classes && c->func == NULL)
1200               || (class == c->class && c->func != NULL)))
1201         {
1202           print_help_for_command (c, prefix, recurse, stream);
1203         }
1204       else if (c->abbrev_flag == 0 && recurse
1205                && class == class_user && c->prefixlist != NULL)
1206         /* User-defined commands may be subcommands.  */
1207         help_cmd_list (*c->prefixlist, class, 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      The XDB compatibility characters are only allowed when using the
1252      right mode because they clash with other GDB commands -
1253      specifically '/' is used as a suffix for print, examine and
1254      display.
1255
1256      Note that this is larger than the character set allowed when
1257      creating user-defined commands.  */
1258
1259   /* Recognize '!' as a single character command so that, e.g., "!ls"
1260      works as expected.  */
1261   if (*p == '!')
1262     return 1;
1263
1264   while (isalnum (*p) || *p == '-' || *p == '_'
1265          /* Characters used by TUI specific commands.  */
1266          || *p == '+' || *p == '<' || *p == '>' || *p == '$'
1267          /* Characters used for XDB compatibility.  */
1268          || (xdb_commands && (*p == '/' || *p == '?')))
1269     p++;
1270
1271   return p - text;
1272 }
1273
1274 /* Return TRUE if NAME is a valid user-defined command name.
1275    This is a stricter subset of all gdb commands,
1276    see find_command_name_length.  */
1277
1278 int
1279 valid_user_defined_cmd_name_p (const char *name)
1280 {
1281   const char *p;
1282
1283   if (*name == '\0')
1284     return FALSE;
1285
1286   /* Alas "42" is a legitimate user-defined command.
1287      In the interests of not breaking anything we preserve that.  */
1288
1289   for (p = name; *p != '\0'; ++p)
1290     {
1291       if (isalnum (*p)
1292           || *p == '-'
1293           || *p == '_')
1294         ; /* Ok.  */
1295       else
1296         return FALSE;
1297     }
1298
1299   return TRUE;
1300 }
1301
1302 /* This routine takes a line of TEXT and a CLIST in which to start the
1303    lookup.  When it returns it will have incremented the text pointer past
1304    the section of text it matched, set *RESULT_LIST to point to the list in
1305    which the last word was matched, and will return a pointer to the cmd
1306    list element which the text matches.  It will return NULL if no match at
1307    all was possible.  It will return -1 (cast appropriately, ick) if ambigous
1308    matches are possible; in this case *RESULT_LIST will be set to point to
1309    the list in which there are ambiguous choices (and *TEXT will be set to
1310    the ambiguous text string).
1311
1312    If the located command was an abbreviation, this routine returns the base
1313    command of the abbreviation.
1314
1315    It does no error reporting whatsoever; control will always return
1316    to the superior routine.
1317
1318    In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1319    at the prefix_command (ie. the best match) *or* (special case) will be NULL
1320    if no prefix command was ever found.  For example, in the case of "info a",
1321    "info" matches without ambiguity, but "a" could be "args" or "address", so
1322    *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
1323    RESULT_LIST should not be interpeted as a pointer to the beginning of a
1324    list; it simply points to a specific command.  In the case of an ambiguous
1325    return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1326    "info t" can be "info types" or "info target"; upon return *TEXT has been
1327    advanced past "info ").
1328
1329    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1330    affect the operation).
1331
1332    This routine does *not* modify the text pointed to by TEXT.
1333
1334    If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1335    are actually help classes rather than commands (i.e. the function field of
1336    the struct cmd_list_element is NULL).  */
1337
1338 struct cmd_list_element *
1339 lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
1340               struct cmd_list_element **result_list, int ignore_help_classes)
1341 {
1342   char *command;
1343   int len, tmp, nfound;
1344   struct cmd_list_element *found, *c;
1345   const char *line = *text;
1346
1347   while (**text == ' ' || **text == '\t')
1348     (*text)++;
1349
1350   /* Identify the name of the command.  */
1351   len = find_command_name_length (*text);
1352
1353   /* If nothing but whitespace, return 0.  */
1354   if (len == 0)
1355     return 0;
1356
1357   /* *text and p now bracket the first command word to lookup (and
1358      it's length is len).  We copy this into a local temporary.  */
1359
1360
1361   command = (char *) alloca (len + 1);
1362   memcpy (command, *text, len);
1363   command[len] = '\0';
1364
1365   /* Look it up.  */
1366   found = 0;
1367   nfound = 0;
1368   found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1369
1370   /* We didn't find the command in the entered case, so lower case it
1371      and search again.  */
1372   if (!found || nfound == 0)
1373     {
1374       for (tmp = 0; tmp < len; tmp++)
1375         {
1376           char x = command[tmp];
1377
1378           command[tmp] = isupper (x) ? tolower (x) : x;
1379         }
1380       found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1381     }
1382
1383   /* If nothing matches, we have a simple failure.  */
1384   if (nfound == 0)
1385     return 0;
1386
1387   if (nfound > 1)
1388     {
1389       if (result_list != NULL)
1390         /* Will be modified in calling routine
1391            if we know what the prefix command is.  */
1392         *result_list = 0;
1393       return CMD_LIST_AMBIGUOUS;        /* Ambiguous.  */
1394     }
1395
1396   /* We've matched something on this list.  Move text pointer forward.  */
1397
1398   *text += len;
1399
1400   if (found->cmd_pointer)
1401     {
1402       /* We drop the alias (abbreviation) in favor of the command it
1403        is pointing to.  If the alias is deprecated, though, we need to
1404        warn the user about it before we drop it.  Note that while we
1405        are warning about the alias, we may also warn about the command
1406        itself and we will adjust the appropriate DEPRECATED_WARN_USER
1407        flags.  */
1408
1409       if (found->deprecated_warn_user)
1410         deprecated_cmd_warning (line);
1411       found = found->cmd_pointer;
1412     }
1413   /* If we found a prefix command, keep looking.  */
1414
1415   if (found->prefixlist)
1416     {
1417       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1418                         ignore_help_classes);
1419       if (!c)
1420         {
1421           /* Didn't find anything; this is as far as we got.  */
1422           if (result_list != NULL)
1423             *result_list = clist;
1424           return found;
1425         }
1426       else if (c == CMD_LIST_AMBIGUOUS)
1427         {
1428           /* We've gotten this far properly, but the next step is
1429              ambiguous.  We need to set the result list to the best
1430              we've found (if an inferior hasn't already set it).  */
1431           if (result_list != NULL)
1432             if (!*result_list)
1433               /* This used to say *result_list = *found->prefixlist.
1434                  If that was correct, need to modify the documentation
1435                  at the top of this function to clarify what is
1436                  supposed to be going on.  */
1437               *result_list = found;
1438           return c;
1439         }
1440       else
1441         {
1442           /* We matched!  */
1443           return c;
1444         }
1445     }
1446   else
1447     {
1448       if (result_list != NULL)
1449         *result_list = clist;
1450       return found;
1451     }
1452 }
1453
1454 /* All this hair to move the space to the front of cmdtype */
1455
1456 static void
1457 undef_cmd_error (const char *cmdtype, const char *q)
1458 {
1459   error (_("Undefined %scommand: \"%s\".  Try \"help%s%.*s\"."),
1460          cmdtype,
1461          q,
1462          *cmdtype ? " " : "",
1463          (int) strlen (cmdtype) - 1,
1464          cmdtype);
1465 }
1466
1467 /* Look up the contents of *LINE as a command in the command list LIST.
1468    LIST is a chain of struct cmd_list_element's.
1469    If it is found, return the struct cmd_list_element for that command
1470    and update *LINE to point after the command name, at the first argument.
1471    If not found, call error if ALLOW_UNKNOWN is zero
1472    otherwise (or if error returns) return zero.
1473    Call error if specified command is ambiguous,
1474    unless ALLOW_UNKNOWN is negative.
1475    CMDTYPE precedes the word "command" in the error message.
1476
1477    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1478    elements which are actually help classes rather than commands (i.e.
1479    the function field of the struct cmd_list_element is 0).  */
1480
1481 struct cmd_list_element *
1482 lookup_cmd (const char **line, struct cmd_list_element *list, char *cmdtype,
1483             int allow_unknown, int ignore_help_classes)
1484 {
1485   struct cmd_list_element *last_list = 0;
1486   struct cmd_list_element *c;
1487
1488   /* Note: Do not remove trailing whitespace here because this
1489      would be wrong for complete_command.  Jim Kingdon  */
1490
1491   if (!*line)
1492     error (_("Lack of needed %scommand"), cmdtype);
1493
1494   c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1495
1496   if (!c)
1497     {
1498       if (!allow_unknown)
1499         {
1500           char *q;
1501           int len = find_command_name_length (*line);
1502
1503           q = (char *) alloca (len + 1);
1504           strncpy (q, *line, len);
1505           q[len] = '\0';
1506           undef_cmd_error (cmdtype, q);
1507         }
1508       else
1509         return 0;
1510     }
1511   else if (c == CMD_LIST_AMBIGUOUS)
1512     {
1513       /* Ambigous.  Local values should be off prefixlist or called
1514          values.  */
1515       int local_allow_unknown = (last_list ? last_list->allow_unknown :
1516                                  allow_unknown);
1517       const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1518       struct cmd_list_element *local_list =
1519         (last_list ? *(last_list->prefixlist) : list);
1520
1521       if (local_allow_unknown < 0)
1522         {
1523           if (last_list)
1524             return last_list;   /* Found something.  */
1525           else
1526             return 0;           /* Found nothing.  */
1527         }
1528       else
1529         {
1530           /* Report as error.  */
1531           int amb_len;
1532           char ambbuf[100];
1533
1534           for (amb_len = 0;
1535                ((*line)[amb_len] && (*line)[amb_len] != ' '
1536                 && (*line)[amb_len] != '\t');
1537                amb_len++)
1538             ;
1539
1540           ambbuf[0] = 0;
1541           for (c = local_list; c; c = c->next)
1542             if (!strncmp (*line, c->name, amb_len))
1543               {
1544                 if (strlen (ambbuf) + strlen (c->name) + 6
1545                     < (int) sizeof ambbuf)
1546                   {
1547                     if (strlen (ambbuf))
1548                       strcat (ambbuf, ", ");
1549                     strcat (ambbuf, c->name);
1550                   }
1551                 else
1552                   {
1553                     strcat (ambbuf, "..");
1554                     break;
1555                   }
1556               }
1557           error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1558                  *line, ambbuf);
1559           return 0;             /* lint */
1560         }
1561     }
1562   else
1563     {
1564       if (c->type == set_cmd && **line != '\0' && !isspace (**line))
1565         error (_("Argument must be preceded by space."));
1566
1567       /* We've got something.  It may still not be what the caller
1568          wants (if this command *needs* a subcommand).  */
1569       while (**line == ' ' || **line == '\t')
1570         (*line)++;
1571
1572       if (c->prefixlist && **line && !c->allow_unknown)
1573         undef_cmd_error (c->prefixname, *line);
1574
1575       /* Seems to be what he wants.  Return it.  */
1576       return c;
1577     }
1578   return 0;
1579 }
1580
1581 /* We are here presumably because an alias or command in TEXT is
1582    deprecated and a warning message should be generated.  This
1583    function decodes TEXT and potentially generates a warning message
1584    as outlined below.
1585
1586    Example for 'set endian big' which has a fictitious alias 'seb'.
1587
1588    If alias wasn't used in TEXT, and the command is deprecated:
1589    "warning: 'set endian big' is deprecated."
1590
1591    If alias was used, and only the alias is deprecated:
1592    "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1593
1594    If alias was used and command is deprecated (regardless of whether
1595    the alias itself is deprecated:
1596
1597    "warning: 'set endian big' (seb) is deprecated."
1598
1599    After the message has been sent, clear the appropriate flags in the
1600    command and/or the alias so the user is no longer bothered.
1601
1602 */
1603 void
1604 deprecated_cmd_warning (const char *text)
1605 {
1606   struct cmd_list_element *alias = NULL;
1607   struct cmd_list_element *prefix_cmd = NULL;
1608   struct cmd_list_element *cmd = NULL;
1609
1610   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
1611     /* Return if text doesn't evaluate to a command.  */
1612     return;
1613
1614   if (!((alias ? alias->deprecated_warn_user : 0)
1615       || cmd->deprecated_warn_user) )
1616     /* Return if nothing is deprecated.  */
1617     return;
1618
1619   printf_filtered ("Warning:");
1620
1621   if (alias && !cmd->cmd_deprecated)
1622     printf_filtered (" '%s', an alias for the", alias->name);
1623
1624   printf_filtered (" command '");
1625
1626   if (prefix_cmd)
1627     printf_filtered ("%s", prefix_cmd->prefixname);
1628
1629   printf_filtered ("%s", cmd->name);
1630
1631   if (alias && cmd->cmd_deprecated)
1632     printf_filtered ("' (%s) is deprecated.\n", alias->name);
1633   else
1634     printf_filtered ("' is deprecated.\n");
1635
1636
1637   /* If it is only the alias that is deprecated, we want to indicate
1638      the new alias, otherwise we'll indicate the new command.  */
1639
1640   if (alias && !cmd->cmd_deprecated)
1641     {
1642       if (alias->replacement)
1643         printf_filtered ("Use '%s'.\n\n", alias->replacement);
1644       else
1645         printf_filtered ("No alternative known.\n\n");
1646      }
1647   else
1648     {
1649       if (cmd->replacement)
1650         printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1651       else
1652         printf_filtered ("No alternative known.\n\n");
1653     }
1654
1655   /* We've warned you, now we'll keep quiet.  */
1656   if (alias)
1657     alias->deprecated_warn_user = 0;
1658
1659   cmd->deprecated_warn_user = 0;
1660 }
1661
1662
1663 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1664    Return 1 on success, 0 on failure.
1665
1666    If LINE refers to an alias, *alias will point to that alias.
1667
1668    If LINE is a postfix command (i.e. one that is preceded by a prefix
1669    command) set *prefix_cmd.
1670
1671    Set *cmd to point to the command LINE indicates.
1672
1673    If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1674    exist, they are NULL when we return.
1675
1676 */
1677 int
1678 lookup_cmd_composition (const char *text,
1679                       struct cmd_list_element **alias,
1680                       struct cmd_list_element **prefix_cmd,
1681                       struct cmd_list_element **cmd)
1682 {
1683   char *command;
1684   int len, tmp, nfound;
1685   struct cmd_list_element *cur_list;
1686   struct cmd_list_element *prev_cmd;
1687
1688   *alias = NULL;
1689   *prefix_cmd = NULL;
1690   *cmd = NULL;
1691
1692   cur_list = cmdlist;
1693
1694   while (1)
1695     {
1696       /* Go through as many command lists as we need to,
1697          to find the command TEXT refers to.  */
1698
1699       prev_cmd = *cmd;
1700
1701       while (*text == ' ' || *text == '\t')
1702         (text)++;
1703
1704       /* Identify the name of the command.  */
1705       len = find_command_name_length (text);
1706
1707       /* If nothing but whitespace, return.  */
1708       if (len == 0)
1709         return 0;
1710
1711       /* Text is the start of the first command word to lookup (and
1712          it's length is len).  We copy this into a local temporary.  */
1713
1714       command = (char *) alloca (len + 1);
1715       memcpy (command, text, len);
1716       command[len] = '\0';
1717
1718       /* Look it up.  */
1719       *cmd = 0;
1720       nfound = 0;
1721       *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1722
1723       /* We didn't find the command in the entered case, so lower case
1724          it and search again.
1725       */
1726       if (!*cmd || nfound == 0)
1727         {
1728           for (tmp = 0; tmp < len; tmp++)
1729             {
1730               char x = command[tmp];
1731
1732               command[tmp] = isupper (x) ? tolower (x) : x;
1733             }
1734           *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1735         }
1736
1737       if (*cmd == CMD_LIST_AMBIGUOUS)
1738         {
1739           return 0;              /* ambiguous */
1740         }
1741
1742       if (*cmd == NULL)
1743         return 0;                /* nothing found */
1744       else
1745         {
1746           if ((*cmd)->cmd_pointer)
1747             {
1748               /* cmd was actually an alias, we note that an alias was
1749                  used (by assigning *alais) and we set *cmd.  */
1750               *alias = *cmd;
1751               *cmd = (*cmd)->cmd_pointer;
1752             }
1753           *prefix_cmd = prev_cmd;
1754         }
1755       if ((*cmd)->prefixlist)
1756         cur_list = *(*cmd)->prefixlist;
1757       else
1758         return 1;
1759
1760       text += len;
1761     }
1762 }
1763
1764 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1765
1766 /* Return a vector of char pointers which point to the different
1767    possible completions in LIST of TEXT.
1768
1769    WORD points in the same buffer as TEXT, and completions should be
1770    returned relative to this position.  For example, suppose TEXT is
1771    "foo" and we want to complete to "foobar".  If WORD is "oo", return
1772    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1773
1774 VEC (char_ptr) *
1775 complete_on_cmdlist (struct cmd_list_element *list,
1776                      const char *text, const char *word,
1777                      int ignore_help_classes)
1778 {
1779   struct cmd_list_element *ptr;
1780   VEC (char_ptr) *matchlist = NULL;
1781   int textlen = strlen (text);
1782   int pass;
1783   int saw_deprecated_match = 0;
1784
1785   /* We do one or two passes.  In the first pass, we skip deprecated
1786      commands.  If we see no matching commands in the first pass, and
1787      if we did happen to see a matching deprecated command, we do
1788      another loop to collect those.  */
1789   for (pass = 0; matchlist == 0 && pass < 2; ++pass)
1790     {
1791       for (ptr = list; ptr; ptr = ptr->next)
1792         if (!strncmp (ptr->name, text, textlen)
1793             && !ptr->abbrev_flag
1794             && (!ignore_help_classes || ptr->func
1795                 || ptr->prefixlist))
1796           {
1797             char *match;
1798
1799             if (pass == 0)
1800               {
1801                 if (ptr->cmd_deprecated)
1802                   {
1803                     saw_deprecated_match = 1;
1804                     continue;
1805                   }
1806               }
1807
1808             match = (char *) xmalloc (strlen (word) + strlen (ptr->name) + 1);
1809             if (word == text)
1810               strcpy (match, ptr->name);
1811             else if (word > text)
1812               {
1813                 /* Return some portion of ptr->name.  */
1814                 strcpy (match, ptr->name + (word - text));
1815               }
1816             else
1817               {
1818                 /* Return some of text plus ptr->name.  */
1819                 strncpy (match, word, text - word);
1820                 match[text - word] = '\0';
1821                 strcat (match, ptr->name);
1822               }
1823             VEC_safe_push (char_ptr, matchlist, match);
1824           }
1825       /* If we saw no matching deprecated commands in the first pass,
1826          just bail out.  */
1827       if (!saw_deprecated_match)
1828         break;
1829     }
1830
1831   return matchlist;
1832 }
1833
1834 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1835
1836 /* Return a vector of char pointers which point to the different
1837    possible completions in CMD of TEXT.
1838
1839    WORD points in the same buffer as TEXT, and completions should be
1840    returned relative to this position.  For example, suppose TEXT is "foo"
1841    and we want to complete to "foobar".  If WORD is "oo", return
1842    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1843
1844 VEC (char_ptr) *
1845 complete_on_enum (const char *const *enumlist,
1846                   const char *text, const char *word)
1847 {
1848   VEC (char_ptr) *matchlist = NULL;
1849   int textlen = strlen (text);
1850   int i;
1851   const char *name;
1852
1853   for (i = 0; (name = enumlist[i]) != NULL; i++)
1854     if (strncmp (name, text, textlen) == 0)
1855       {
1856         char *match;
1857
1858         match = (char *) xmalloc (strlen (word) + strlen (name) + 1);
1859         if (word == text)
1860           strcpy (match, name);
1861         else if (word > text)
1862           {
1863             /* Return some portion of name.  */
1864             strcpy (match, name + (word - text));
1865           }
1866         else
1867           {
1868             /* Return some of text plus name.  */
1869             strncpy (match, word, text - word);
1870             match[text - word] = '\0';
1871             strcat (match, name);
1872           }
1873         VEC_safe_push (char_ptr, matchlist, match);
1874       }
1875
1876   return matchlist;
1877 }
1878
1879
1880 /* Check function pointer.  */
1881 int
1882 cmd_func_p (struct cmd_list_element *cmd)
1883 {
1884   return (cmd->func != NULL);
1885 }
1886
1887
1888 /* Call the command function.  */
1889 void
1890 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
1891 {
1892   if (cmd_func_p (cmd))
1893     (*cmd->func) (cmd, args, from_tty);
1894   else
1895     error (_("Invalid command"));
1896 }
1897
1898 int
1899 cli_user_command_p (struct cmd_list_element *cmd)
1900 {
1901   return (cmd->class == class_user
1902           && (cmd->func == do_cfunc || cmd->func == do_sfunc));
1903 }