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