gdb/cli/cli-decode.c

   1 /* Handle lists of commands, their decoding and documentation, for GDB.
   2
   3    Copyright (C) 1986-2019 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, int *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 seperate comamnds, 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 (isalnum (*p) || *p == '-' || *p == '_'
1376          /* Characters used by TUI specific commands.  */
1377          || *p == '+' || *p == '<' || *p == '>' || *p == '$')
1378     p++;
1379
1380   return p - text;
1381 }
1382
1383 /* Return TRUE if NAME is a valid user-defined command name.
1384    This is a stricter subset of all gdb commands,
1385    see find_command_name_length.  */
1386
1387 bool
1388 valid_user_defined_cmd_name_p (const char *name)
1389 {
1390   const char *p;
1391
1392   if (*name == '\0')
1393     return false;
1394
1395   /* Alas "42" is a legitimate user-defined command.
1396      In the interests of not breaking anything we preserve that.  */
1397
1398   for (p = name; *p != '\0'; ++p)
1399     {
1400       if (isalnum (*p)
1401           || *p == '-'
1402           || *p == '_')
1403         ; /* Ok.  */
1404       else
1405         return false;
1406     }
1407
1408   return true;
1409 }
1410
1411 /* This routine takes a line of TEXT and a CLIST in which to start the
1412    lookup.  When it returns it will have incremented the text pointer past
1413    the section of text it matched, set *RESULT_LIST to point to the list in
1414    which the last word was matched, and will return a pointer to the cmd
1415    list element which the text matches.  It will return NULL if no match at
1416    all was possible.  It will return -1 (cast appropriately, ick) if ambigous
1417    matches are possible; in this case *RESULT_LIST will be set to point to
1418    the list in which there are ambiguous choices (and *TEXT will be set to
1419    the ambiguous text string).
1420
1421    If the located command was an abbreviation, this routine returns the base
1422    command of the abbreviation.
1423
1424    It does no error reporting whatsoever; control will always return
1425    to the superior routine.
1426
1427    In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1428    at the prefix_command (ie. the best match) *or* (special case) will be NULL
1429    if no prefix command was ever found.  For example, in the case of "info a",
1430    "info" matches without ambiguity, but "a" could be "args" or "address", so
1431    *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
1432    RESULT_LIST should not be interpreted as a pointer to the beginning of a
1433    list; it simply points to a specific command.  In the case of an ambiguous
1434    return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1435    "info t" can be "info types" or "info target"; upon return *TEXT has been
1436    advanced past "info ").
1437
1438    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1439    affect the operation).
1440
1441    This routine does *not* modify the text pointed to by TEXT.
1442
1443    If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1444    are actually help classes rather than commands (i.e. the function field of
1445    the struct cmd_list_element is NULL).  */
1446
1447 struct cmd_list_element *
1448 lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
1449               struct cmd_list_element **result_list, int ignore_help_classes)
1450 {
1451   char *command;
1452   int len, nfound;
1453   struct cmd_list_element *found, *c;
1454   const char *line = *text;
1455
1456   while (**text == ' ' || **text == '\t')
1457     (*text)++;
1458
1459   /* Identify the name of the command.  */
1460   len = find_command_name_length (*text);
1461
1462   /* If nothing but whitespace, return 0.  */
1463   if (len == 0)
1464     return 0;
1465
1466   /* *text and p now bracket the first command word to lookup (and
1467      it's length is len).  We copy this into a local temporary.  */
1468
1469
1470   command = (char *) alloca (len + 1);
1471   memcpy (command, *text, len);
1472   command[len] = '\0';
1473
1474   /* Look it up.  */
1475   found = 0;
1476   nfound = 0;
1477   found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1478
1479   /* If nothing matches, we have a simple failure.  */
1480   if (nfound == 0)
1481     return 0;
1482
1483   if (nfound > 1)
1484     {
1485       if (result_list != NULL)
1486         /* Will be modified in calling routine
1487            if we know what the prefix command is.  */
1488         *result_list = 0;
1489       return CMD_LIST_AMBIGUOUS;        /* Ambiguous.  */
1490     }
1491
1492   /* We've matched something on this list.  Move text pointer forward.  */
1493
1494   *text += len;
1495
1496   if (found->cmd_pointer)
1497     {
1498       /* We drop the alias (abbreviation) in favor of the command it
1499        is pointing to.  If the alias is deprecated, though, we need to
1500        warn the user about it before we drop it.  Note that while we
1501        are warning about the alias, we may also warn about the command
1502        itself and we will adjust the appropriate DEPRECATED_WARN_USER
1503        flags.  */
1504
1505       if (found->deprecated_warn_user)
1506         deprecated_cmd_warning (line);
1507       found = found->cmd_pointer;
1508     }
1509   /* If we found a prefix command, keep looking.  */
1510
1511   if (found->prefixlist)
1512     {
1513       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1514                         ignore_help_classes);
1515       if (!c)
1516         {
1517           /* Didn't find anything; this is as far as we got.  */
1518           if (result_list != NULL)
1519             *result_list = clist;
1520           return found;
1521         }
1522       else if (c == CMD_LIST_AMBIGUOUS)
1523         {
1524           /* We've gotten this far properly, but the next step is
1525              ambiguous.  We need to set the result list to the best
1526              we've found (if an inferior hasn't already set it).  */
1527           if (result_list != NULL)
1528             if (!*result_list)
1529               /* This used to say *result_list = *found->prefixlist.
1530                  If that was correct, need to modify the documentation
1531                  at the top of this function to clarify what is
1532                  supposed to be going on.  */
1533               *result_list = found;
1534           return c;
1535         }
1536       else
1537         {
1538           /* We matched!  */
1539           return c;
1540         }
1541     }
1542   else
1543     {
1544       if (result_list != NULL)
1545         *result_list = clist;
1546       return found;
1547     }
1548 }
1549
1550 /* All this hair to move the space to the front of cmdtype */
1551
1552 static void
1553 undef_cmd_error (const char *cmdtype, const char *q)
1554 {
1555   error (_("Undefined %scommand: \"%s\".  Try \"help%s%.*s\"."),
1556          cmdtype,
1557          q,
1558          *cmdtype ? " " : "",
1559          (int) strlen (cmdtype) - 1,
1560          cmdtype);
1561 }
1562
1563 /* Look up the contents of *LINE as a command in the command list LIST.
1564    LIST is a chain of struct cmd_list_element's.
1565    If it is found, return the struct cmd_list_element for that command
1566    and update *LINE to point after the command name, at the first argument.
1567    If not found, call error if ALLOW_UNKNOWN is zero
1568    otherwise (or if error returns) return zero.
1569    Call error if specified command is ambiguous,
1570    unless ALLOW_UNKNOWN is negative.
1571    CMDTYPE precedes the word "command" in the error message.
1572
1573    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1574    elements which are actually help classes rather than commands (i.e.
1575    the function field of the struct cmd_list_element is 0).  */
1576
1577 struct cmd_list_element *
1578 lookup_cmd (const char **line, struct cmd_list_element *list,
1579             const char *cmdtype,
1580             int allow_unknown, int ignore_help_classes)
1581 {
1582   struct cmd_list_element *last_list = 0;
1583   struct cmd_list_element *c;
1584
1585   /* Note: Do not remove trailing whitespace here because this
1586      would be wrong for complete_command.  Jim Kingdon  */
1587
1588   if (!*line)
1589     error (_("Lack of needed %scommand"), cmdtype);
1590
1591   c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1592
1593   if (!c)
1594     {
1595       if (!allow_unknown)
1596         {
1597           char *q;
1598           int len = find_command_name_length (*line);
1599
1600           q = (char *) alloca (len + 1);
1601           strncpy (q, *line, len);
1602           q[len] = '\0';
1603           undef_cmd_error (cmdtype, q);
1604         }
1605       else
1606         return 0;
1607     }
1608   else if (c == CMD_LIST_AMBIGUOUS)
1609     {
1610       /* Ambigous.  Local values should be off prefixlist or called
1611          values.  */
1612       int local_allow_unknown = (last_list ? last_list->allow_unknown :
1613                                  allow_unknown);
1614       const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1615       struct cmd_list_element *local_list =
1616         (last_list ? *(last_list->prefixlist) : list);
1617
1618       if (local_allow_unknown < 0)
1619         {
1620           if (last_list)
1621             return last_list;   /* Found something.  */
1622           else
1623             return 0;           /* Found nothing.  */
1624         }
1625       else
1626         {
1627           /* Report as error.  */
1628           int amb_len;
1629           char ambbuf[100];
1630
1631           for (amb_len = 0;
1632                ((*line)[amb_len] && (*line)[amb_len] != ' '
1633                 && (*line)[amb_len] != '\t');
1634                amb_len++)
1635             ;
1636
1637           ambbuf[0] = 0;
1638           for (c = local_list; c; c = c->next)
1639             if (!strncmp (*line, c->name, amb_len))
1640               {
1641                 if (strlen (ambbuf) + strlen (c->name) + 6
1642                     < (int) sizeof ambbuf)
1643                   {
1644                     if (strlen (ambbuf))
1645                       strcat (ambbuf, ", ");
1646                     strcat (ambbuf, c->name);
1647                   }
1648                 else
1649                   {
1650                     strcat (ambbuf, "..");
1651                     break;
1652                   }
1653               }
1654           error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1655                  *line, ambbuf);
1656         }
1657     }
1658   else
1659     {
1660       if (c->type == set_cmd && **line != '\0' && !isspace (**line))
1661         error (_("Argument must be preceded by space."));
1662
1663       /* We've got something.  It may still not be what the caller
1664          wants (if this command *needs* a subcommand).  */
1665       while (**line == ' ' || **line == '\t')
1666         (*line)++;
1667
1668       if (c->prefixlist && **line && !c->allow_unknown)
1669         undef_cmd_error (c->prefixname, *line);
1670
1671       /* Seems to be what he wants.  Return it.  */
1672       return c;
1673     }
1674   return 0;
1675 }
1676
1677 /* We are here presumably because an alias or command in TEXT is
1678    deprecated and a warning message should be generated.  This
1679    function decodes TEXT and potentially generates a warning message
1680    as outlined below.
1681
1682    Example for 'set endian big' which has a fictitious alias 'seb'.
1683
1684    If alias wasn't used in TEXT, and the command is deprecated:
1685    "warning: 'set endian big' is deprecated."
1686
1687    If alias was used, and only the alias is deprecated:
1688    "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1689
1690    If alias was used and command is deprecated (regardless of whether
1691    the alias itself is deprecated:
1692
1693    "warning: 'set endian big' (seb) is deprecated."
1694
1695    After the message has been sent, clear the appropriate flags in the
1696    command and/or the alias so the user is no longer bothered.
1697
1698 */
1699 void
1700 deprecated_cmd_warning (const char *text)
1701 {
1702   struct cmd_list_element *alias = NULL;
1703   struct cmd_list_element *prefix_cmd = NULL;
1704   struct cmd_list_element *cmd = NULL;
1705
1706   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
1707     /* Return if text doesn't evaluate to a command.  */
1708     return;
1709
1710   if (!((alias ? alias->deprecated_warn_user : 0)
1711       || cmd->deprecated_warn_user) )
1712     /* Return if nothing is deprecated.  */
1713     return;
1714
1715   printf_filtered ("Warning:");
1716
1717   if (alias && !cmd->cmd_deprecated)
1718     printf_filtered (" '%s', an alias for the", alias->name);
1719
1720   printf_filtered (" command '");
1721
1722   if (prefix_cmd)
1723     printf_filtered ("%s", prefix_cmd->prefixname);
1724
1725   printf_filtered ("%s", cmd->name);
1726
1727   if (alias && cmd->cmd_deprecated)
1728     printf_filtered ("' (%s) is deprecated.\n", alias->name);
1729   else
1730     printf_filtered ("' is deprecated.\n");
1731
1732
1733   /* If it is only the alias that is deprecated, we want to indicate
1734      the new alias, otherwise we'll indicate the new command.  */
1735
1736   if (alias && !cmd->cmd_deprecated)
1737     {
1738       if (alias->replacement)
1739         printf_filtered ("Use '%s'.\n\n", alias->replacement);
1740       else
1741         printf_filtered ("No alternative known.\n\n");
1742      }
1743   else
1744     {
1745       if (cmd->replacement)
1746         printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1747       else
1748         printf_filtered ("No alternative known.\n\n");
1749     }
1750
1751   /* We've warned you, now we'll keep quiet.  */
1752   if (alias)
1753     alias->deprecated_warn_user = 0;
1754
1755   cmd->deprecated_warn_user = 0;
1756 }
1757
1758
1759 /* Look up the contents of LINE as a command in the command list 'cmdlist'.
1760    Return 1 on success, 0 on failure.
1761
1762    If LINE refers to an alias, *alias will point to that alias.
1763
1764    If LINE is a postfix command (i.e. one that is preceded by a prefix
1765    command) set *prefix_cmd.
1766
1767    Set *cmd to point to the command LINE indicates.
1768
1769    If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
1770    exist, they are NULL when we return.
1771
1772 */
1773 int
1774 lookup_cmd_composition (const char *text,
1775                       struct cmd_list_element **alias,
1776                       struct cmd_list_element **prefix_cmd,
1777                       struct cmd_list_element **cmd)
1778 {
1779   char *command;
1780   int len, nfound;
1781   struct cmd_list_element *cur_list;
1782   struct cmd_list_element *prev_cmd;
1783
1784   *alias = NULL;
1785   *prefix_cmd = NULL;
1786   *cmd = NULL;
1787
1788   cur_list = cmdlist;
1789
1790   while (1)
1791     {
1792       /* Go through as many command lists as we need to,
1793          to find the command TEXT refers to.  */
1794
1795       prev_cmd = *cmd;
1796
1797       while (*text == ' ' || *text == '\t')
1798         (text)++;
1799
1800       /* Identify the name of the command.  */
1801       len = find_command_name_length (text);
1802
1803       /* If nothing but whitespace, return.  */
1804       if (len == 0)
1805         return 0;
1806
1807       /* Text is the start of the first command word to lookup (and
1808          it's length is len).  We copy this into a local temporary.  */
1809
1810       command = (char *) alloca (len + 1);
1811       memcpy (command, text, len);
1812       command[len] = '\0';
1813
1814       /* Look it up.  */
1815       *cmd = 0;
1816       nfound = 0;
1817       *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1818
1819       if (*cmd == CMD_LIST_AMBIGUOUS)
1820         {
1821           return 0;              /* ambiguous */
1822         }
1823
1824       if (*cmd == NULL)
1825         return 0;                /* nothing found */
1826       else
1827         {
1828           if ((*cmd)->cmd_pointer)
1829             {
1830               /* cmd was actually an alias, we note that an alias was
1831                  used (by assigning *alais) and we set *cmd.  */
1832               *alias = *cmd;
1833               *cmd = (*cmd)->cmd_pointer;
1834             }
1835           *prefix_cmd = prev_cmd;
1836         }
1837       if ((*cmd)->prefixlist)
1838         cur_list = *(*cmd)->prefixlist;
1839       else
1840         return 1;
1841
1842       text += len;
1843     }
1844 }
1845
1846 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1847
1848 /* Return a vector of char pointers which point to the different
1849    possible completions in LIST of TEXT.
1850
1851    WORD points in the same buffer as TEXT, and completions should be
1852    returned relative to this position.  For example, suppose TEXT is
1853    "foo" and we want to complete to "foobar".  If WORD is "oo", return
1854    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1855
1856 void
1857 complete_on_cmdlist (struct cmd_list_element *list,
1858                      completion_tracker &tracker,
1859                      const char *text, const char *word,
1860                      int ignore_help_classes)
1861 {
1862   struct cmd_list_element *ptr;
1863   int textlen = strlen (text);
1864   int pass;
1865   int saw_deprecated_match = 0;
1866
1867   /* We do one or two passes.  In the first pass, we skip deprecated
1868      commands.  If we see no matching commands in the first pass, and
1869      if we did happen to see a matching deprecated command, we do
1870      another loop to collect those.  */
1871   for (pass = 0; pass < 2; ++pass)
1872     {
1873       bool got_matches = false;
1874
1875       for (ptr = list; ptr; ptr = ptr->next)
1876         if (!strncmp (ptr->name, text, textlen)
1877             && !ptr->abbrev_flag
1878             && (!ignore_help_classes || ptr->func
1879                 || ptr->prefixlist))
1880           {
1881             if (pass == 0)
1882               {
1883                 if (ptr->cmd_deprecated)
1884                   {
1885                     saw_deprecated_match = 1;
1886                     continue;
1887                   }
1888               }
1889
1890             tracker.add_completion
1891               (make_completion_match_str (ptr->name, text, word));
1892             got_matches = true;
1893           }
1894
1895       if (got_matches)
1896         break;
1897
1898       /* If we saw no matching deprecated commands in the first pass,
1899          just bail out.  */
1900       if (!saw_deprecated_match)
1901         break;
1902     }
1903 }
1904
1905 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1906
1907 /* Add the different possible completions in ENUMLIST of TEXT.
1908
1909    WORD points in the same buffer as TEXT, and completions should be
1910    returned relative to this position.  For example, suppose TEXT is "foo"
1911    and we want to complete to "foobar".  If WORD is "oo", return
1912    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1913
1914 void
1915 complete_on_enum (completion_tracker &tracker,
1916                   const char *const *enumlist,
1917                   const char *text, const char *word)
1918 {
1919   int textlen = strlen (text);
1920   int i;
1921   const char *name;
1922
1923   for (i = 0; (name = enumlist[i]) != NULL; i++)
1924     if (strncmp (name, text, textlen) == 0)
1925       tracker.add_completion (make_completion_match_str (name, text, word));
1926 }
1927
1928
1929 /* Check function pointer.  */
1930 int
1931 cmd_func_p (struct cmd_list_element *cmd)
1932 {
1933   return (cmd->func != NULL);
1934 }
1935
1936
1937 /* Call the command function.  */
1938 void
1939 cmd_func (struct cmd_list_element *cmd, const char *args, int from_tty)
1940 {
1941   if (cmd_func_p (cmd))
1942     {
1943       gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
1944
1945       if (cmd->suppress_notification != NULL)
1946         restore_suppress.emplace (cmd->suppress_notification, 1);
1947
1948       (*cmd->func) (cmd, args, from_tty);
1949     }
1950   else
1951     error (_("Invalid command"));
1952 }
1953
1954 int
1955 cli_user_command_p (struct cmd_list_element *cmd)
1956 {
1957   return (cmd->theclass == class_user
1958           && (cmd->func == do_const_cfunc || cmd->func == do_sfunc));
1959 }