gdb/cli/cli-decode.c

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