gdb/cli/cli-decode.c

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