gdb/cli/cli-decode.c - gdb

Global variables defined

Functions defined

Source code

  1. /* Handle lists of commands, their decoding and documentation, for GDB.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 3 of the License, or
  8.    (at your option) any later version.

  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.

  15.    You should have received a copy of the GNU General Public License
  16.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  18. #include "defs.h"
  19. #include "symtab.h"
  20. #include <ctype.h>
  21. #include "gdb_regex.h"
  22. #include "completer.h"
  23. #include "ui-out.h"
  24. #include "cli/cli-cmds.h"
  25. #include "cli/cli-decode.h"

  27. /* Prototypes for local functions.  */

  29. static void undef_cmd_error (const char *, const char *);

  31. static struct cmd_list_element *delete_cmd (const char *name,
  32.                                             struct cmd_list_element **list,
  33.                                             struct cmd_list_element **prehook,
  34.                                             struct cmd_list_element **prehookee,
  35.                                             struct cmd_list_element **posthook,
  36.                                             struct cmd_list_element **posthookee);

  38. static struct cmd_list_element *find_cmd (const char *command,
  39.                                           int len,
  40.                                           struct cmd_list_element *clist,
  41.                                           int ignore_help_classes,
  42.                                           int *nfound);

  44. static void help_all (struct ui_file *stream);

  46. /* Look up a command whose 'prefixlist' is KEY.  Return the command if found,
  47.    otherwise return NULL.  */

  49. static struct cmd_list_element *
  50. ‌lookup_cmd_for_prefixlist (struct cmd_list_element **key,
  51.                            struct cmd_list_element *list)
  52. {
  53.   struct cmd_list_element *p = NULL;

  55.   for (p = list; p != NULL; p = p->next)
  56.     {
  57.       struct cmd_list_element *q;

  59.       if (p->prefixlist == NULL)
  60.         continue;
  61.       else if (p->prefixlist == key)
  62.         return p;

  64.       q = lookup_cmd_for_prefixlist (key, *(p->prefixlist));
  65.       if (q != NULL)
  66.         return q;
  67.     }

  69.   return NULL;
  70. }

  72. static void
  73. ‌set_cmd_prefix (struct cmd_list_element *c, struct cmd_list_element **list)
  74. {
  75.   struct cmd_list_element *p;

  77.   /* Check to see if *LIST contains any element other than C.  */
  78.   for (p = *list; p != NULL; p = p->next)
  79.     if (p != c)
  80.       break;

  82.   if (p == NULL)
  83.     {
  84.       /* *SET_LIST only contains SET.  */
  85.       p = lookup_cmd_for_prefixlist (list, setlist);

  87.       c->prefix = p ? (p->cmd_pointer ? p->cmd_pointer : p) : p;
  88.     }
  89.   else
  90.     c->prefix = p->prefix;
  91. }

  93. static void
  94. print_help_for_command (struct cmd_list_element *c, const char *prefix,
  95.                         int recurse, struct ui_file *stream);


  98. /* Set the callback function for the specified command.  For each both
  99.    the commands callback and func() are set.  The latter set to a
  100.    bounce function (unless cfunc / sfunc is NULL that is).  */

  102. static void
  103. ‌do_cfunc (struct cmd_list_element *c, char *args, int from_tty)
  104. {
  105.   c->function.cfunc (args, from_tty); /* Ok.  */
  106. }

  108. void
  109. ‌set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
  110. {
  111.   if (cfunc == NULL)
  112.     cmd->func = NULL;
  113.   else
  114.     cmd->func = do_cfunc;
  115.   cmd->function.cfunc = cfunc; /* Ok.  */
  116. }

  118. static void
  119. ‌do_sfunc (struct cmd_list_element *c, char *args, int from_tty)
  120. {
  121.   c->function.sfunc (args, from_tty, c); /* Ok.  */
  122. }

  124. void
  125. ‌set_cmd_sfunc (struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc)
  126. {
  127.   if (sfunc == NULL)
  128.     cmd->func = NULL;
  129.   else
  130.     cmd->func = do_sfunc;
  131.   cmd->function.sfunc = sfunc; /* Ok.  */
  132. }

  134. int
  135. ‌cmd_cfunc_eq (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc)
  136. {
  137.   return cmd->func == do_cfunc && cmd->function.cfunc == cfunc;
  138. }

  140. void
  141. ‌set_cmd_context (struct cmd_list_element *cmd, void *context)
  142. {
  143.   cmd->context = context;
  144. }

  146. void *
  147. ‌get_cmd_context (struct cmd_list_element *cmd)
  148. {
  149.   return cmd->context;
  150. }

  152. enum cmd_types
  153. ‌cmd_type (struct cmd_list_element *cmd)
  154. {
  155.   return cmd->type;
  156. }

  158. void
  159. ‌set_cmd_completer (struct cmd_list_element *cmd, completer_ftype *completer)
  160. {
  161.   cmd->completer = completer; /* Ok.  */
  162. }

  164. /* See definition in commands.h.  */

  166. void
  167. ‌set_cmd_completer_handle_brkchars (struct cmd_list_element *cmd,
  168.                                completer_ftype_void *completer_handle_brkchars)
  169. {
  170.   cmd->completer_handle_brkchars = completer_handle_brkchars;
  171. }

  173. /* Add element named NAME.
  174.    Space for NAME and DOC must be allocated by the caller.
  175.    CLASS is the top level category into which commands are broken down
  176.    for "help" purposes.
  177.    FUN should be the function to execute the command;
  178.    it will get a character string as argument, with leading
  179.    and trailing blanks already eliminated.

  181.    DOC is a documentation string for the command.
  182.    Its first line should be a complete sentence.
  183.    It should start with ? for a command that is an abbreviation
  184.    or with * for a command that most users don't need to know about.

  186.    Add this command to command list *LIST.

  188.    Returns a pointer to the added command (not necessarily the head
  189.    of *LIST).  */

  191. struct cmd_list_element *
  192. ‌add_cmd (const char *name, enum command_class class, cmd_cfunc_ftype *fun,
  193.          const char *doc, struct cmd_list_element **list)
  194. {
  195.   struct cmd_list_element *c
  196.     = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
  197.   struct cmd_list_element *p, *iter;

  199.   /* Turn each alias of the old command into an alias of the new
  200.      command.  */
  201.   c->aliases = delete_cmd (name, list, &c->hook_pre, &c->hookee_pre,
  202.                            &c->hook_post, &c->hookee_post);
  203.   for (iter = c->aliases; iter; iter = iter->alias_chain)
  204.     iter->cmd_pointer = c;
  205.   if (c->hook_pre)
  206.     c->hook_pre->hookee_pre = c;
  207.   if (c->hookee_pre)
  208.     c->hookee_pre->hook_pre = c;
  209.   if (c->hook_post)
  210.     c->hook_post->hookee_post = c;
  211.   if (c->hookee_post)
  212.     c->hookee_post->hook_post = c;

  214.   if (*list == NULL || strcmp ((*list)->name, name) >= 0)
  215.     {
  216.       c->next = *list;
  217.       *list = c;
  218.     }
  219.   else
  220.     {
  221.       p = *list;
  222.       while (p->next && strcmp (p->next->name, name) <= 0)
  223.         {
  224.           p = p->next;
  225.         }
  226.       c->next = p->next;
  227.       p->next = c;
  228.     }

  230.   c->name = name;
  231.   c->class = class;
  232.   set_cmd_cfunc (c, fun);
  233.   set_cmd_context (c, NULL);
  234.   c->doc = doc;
  235.   c->cmd_deprecated = 0;
  236.   c->deprecated_warn_user = 0;
  237.   c->malloced_replacement = 0;
  238.   c->doc_allocated = 0;
  239.   c->replacement = NULL;
  240.   c->pre_show_hook = NULL;
  241.   c->hook_in = 0;
  242.   c->prefixlist = NULL;
  243.   c->prefixname = NULL;
  244.   c->allow_unknown = 0;
  245.   c->prefix = NULL;
  246.   c->abbrev_flag = 0;
  247.   set_cmd_completer (c, make_symbol_completion_list_fn);
  248.   c->completer_handle_brkchars = NULL;
  249.   c->destroyer = NULL;
  250.   c->type = not_set_cmd;
  251.   c->var = NULL;
  252.   c->var_type = var_boolean;
  253.   c->enums = NULL;
  254.   c->user_commands = NULL;
  255.   c->cmd_pointer = NULL;
  256.   c->alias_chain = NULL;

  258.   return c;
  259. }

  261. /* Deprecates a command CMD.
  262.    REPLACEMENT is the name of the command which should be used in
  263.    place of this command, or NULL if no such command exists.

  265.    This function does not check to see if command REPLACEMENT exists
  266.    since gdb may not have gotten around to adding REPLACEMENT when
  267.    this function is called.

  269.    Returns a pointer to the deprecated command.  */

  271. struct cmd_list_element *
  272. ‌deprecate_cmd (struct cmd_list_element *cmd, const char *replacement)
  273. {
  274.   cmd->cmd_deprecated = 1;
  275.   cmd->deprecated_warn_user = 1;

  277.   if (replacement != NULL)
  278.     cmd->replacement = replacement;
  279.   else
  280.     cmd->replacement = NULL;

  282.   return cmd;
  283. }

  285. struct cmd_list_element *
  286. ‌add_alias_cmd (const char *name, const char *oldname, enum command_class class,
  287.                int abbrev_flag, struct cmd_list_element **list)
  288. {
  289.   const char *tmp;
  290.   struct cmd_list_element *old;
  291.   struct cmd_list_element *c;

  293.   tmp = oldname;
  294.   old = lookup_cmd (&tmp, *list, "", 1, 1);

  296.   if (old == 0)
  297.     {
  298.       struct cmd_list_element *prehook, *prehookee, *posthook, *posthookee;
  299.       struct cmd_list_element *aliases = delete_cmd (name, list,
  300.                                                      &prehook, &prehookee,
  301.                                                      &posthook, &posthookee);

  303.       /* If this happens, it means a programmer error somewhere.  */
  304.       gdb_assert (!aliases && !prehook && !prehookee
  305.                   && !posthook && ! posthookee);
  306.       return 0;
  307.     }

  309.   c = add_cmd (name, class, NULL, old->doc, list);

  311.   /* If OLD->DOC can be freed, we should make another copy.  */
  312.   if (old->doc_allocated)
  313.     {
  314.       c->doc = xstrdup (old->doc);
  315.       c->doc_allocated = 1;
  316.     }
  317.   /* NOTE: Both FUNC and all the FUNCTIONs need to be copied.  */
  318.   c->func = old->func;
  319.   c->function = old->function;
  320.   c->prefixlist = old->prefixlist;
  321.   c->prefixname = old->prefixname;
  322.   c->allow_unknown = old->allow_unknown;
  323.   c->abbrev_flag = abbrev_flag;
  324.   c->cmd_pointer = old;
  325.   c->alias_chain = old->aliases;
  326.   old->aliases = c;

  328.   set_cmd_prefix (c, list);
  329.   return c;
  330. }

  332. /* Like add_cmd but adds an element for a command prefix: a name that
  333.    should be followed by a subcommand to be looked up in another
  334.    command list.  PREFIXLIST should be the address of the variable
  335.    containing that list.  */

  337. struct cmd_list_element *
  338. ‌add_prefix_cmd (const char *name, enum command_class class,
  339.                 cmd_cfunc_ftype *fun,
  340.                 const char *doc, struct cmd_list_element **prefixlist,
  341.                 const char *prefixname, int allow_unknown,
  342.                 struct cmd_list_element **list)
  343. {
  344.   struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
  345.   struct cmd_list_element *p;

  347.   c->prefixlist = prefixlist;
  348.   c->prefixname = prefixname;
  349.   c->allow_unknown = allow_unknown;

  351.   if (list == &cmdlist)
  352.     c->prefix = NULL;
  353.   else
  354.     set_cmd_prefix (c, list);

  356.   /* Update the field 'prefix' of each cmd_list_element in *PREFIXLIST.  */
  357.   for (p = *prefixlist; p != NULL; p = p->next)
  358.     p->prefix = c;

  360.   return c;
  361. }

  363. /* Like add_prefix_cmd but sets the abbrev_flag on the new command.  */

  365. struct cmd_list_element *
  366. ‌add_abbrev_prefix_cmd (const char *name, enum command_class class,
  367.                        cmd_cfunc_ftype *fun, const char *doc,
  368.                        struct cmd_list_element **prefixlist,
  369.                        const char *prefixname,
  370.                        int allow_unknown, struct cmd_list_element **list)
  371. {
  372.   struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);

  374.   c->prefixlist = prefixlist;
  375.   c->prefixname = prefixname;
  376.   c->allow_unknown = allow_unknown;
  377.   c->abbrev_flag = 1;
  378.   return c;
  379. }

  381. /* This is an empty "cfunc".  */
  382. void
  383. ‌not_just_help_class_command (char *args, int from_tty)
  384. {
  385. }

  387. /* This is an empty "sfunc".  */
  388. static void empty_sfunc (char *, int, struct cmd_list_element *);

  390. static void
  391. ‌empty_sfunc (char *args, int from_tty, struct cmd_list_element *c)
  392. {
  393. }

  395. /* Add element named NAME to command list LIST (the list for set/show
  396.    or some sublist thereof).
  397.    TYPE is set_cmd or show_cmd.
  398.    CLASS is as in add_cmd.
  399.    VAR_TYPE is the kind of thing we are setting.
  400.    VAR is address of the variable being controlled by this command.
  401.    DOC is the documentation string.  */

  403. static struct cmd_list_element *
  404. ‌add_set_or_show_cmd (const char *name,
  405.                      enum cmd_types type,
  406.                      enum command_class class,
  407.                      var_types var_type,
  408.                      void *var,
  409.                      const char *doc,
  410.                      struct cmd_list_element **list)
  411. {
  412.   struct cmd_list_element *c = add_cmd (name, class, NULL, doc, list);

  414.   gdb_assert (type == set_cmd || type == show_cmd);
  415.   c->type = type;
  416.   c->var_type = var_type;
  417.   c->var = var;
  418.   /* This needs to be something besides NULL so that this isn't
  419.      treated as a help class.  */
  420.   set_cmd_sfunc (c, empty_sfunc);
  421.   return c;
  422. }

  424. /* Add element named NAME to both the command SET_LIST and SHOW_LIST.
  425.    CLASS is as in add_cmd.  VAR_TYPE is the kind of thing we are
  426.    setting.  VAR is address of the variable being controlled by this
  427.    command.  SET_FUNC and SHOW_FUNC are the callback functions (if
  428.    non-NULL).  SET_DOC, SHOW_DOC and HELP_DOC are the documentation
  429.    strings.  PRINT the format string to print the value.  SET_RESULT
  430.    and SHOW_RESULT, if not NULL, are set to the resulting command
  431.    structures.  */

  433. static void
  434. ‌add_setshow_cmd_full (const char *name,
  435.                       enum command_class class,
  436.                       var_types var_type, void *var,
  437.                       const char *set_doc, const char *show_doc,
  438.                       const char *help_doc,
  439.                       cmd_sfunc_ftype *set_func,
  440.                       show_value_ftype *show_func,
  441.                       struct cmd_list_element **set_list,
  442.                       struct cmd_list_element **show_list,
  443.                       struct cmd_list_element **set_result,
  444.                       struct cmd_list_element **show_result)
  445. {
  446.   struct cmd_list_element *set;
  447.   struct cmd_list_element *show;
  448.   char *full_set_doc;
  449.   char *full_show_doc;

  451.   if (help_doc != NULL)
  452.     {
  453.       full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc);
  454.       full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc);
  455.     }
  456.   else
  457.     {
  458.       full_set_doc = xstrdup (set_doc);
  459.       full_show_doc = xstrdup (show_doc);
  460.     }
  461.   set = add_set_or_show_cmd (name, set_cmd, class, var_type, var,
  462.                              full_set_doc, set_list);
  463.   set->doc_allocated = 1;

  465.   if (set_func != NULL)
  466.     set_cmd_sfunc (set, set_func);

  468.   set_cmd_prefix (set, set_list);

  470.   show = add_set_or_show_cmd (name, show_cmd, class, var_type, var,
  471.                               full_show_doc, show_list);
  472.   show->doc_allocated = 1;
  473.   show->show_value_func = show_func;

  475.   if (set_result != NULL)
  476.     *set_result = set;
  477.   if (show_result != NULL)
  478.     *show_result = show;
  479. }

  481. /* Add element named NAME to command list LIST (the list for set or
  482.    some sublist thereof).  CLASS is as in add_cmd.  ENUMLIST is a list
  483.    of strings which may follow NAME.  VAR is address of the variable
  484.    which will contain the matching string (from ENUMLIST).  */

  486. void
  487. ‌add_setshow_enum_cmd (const char *name,
  488.                       enum command_class class,
  489.                       const char *const *enumlist,
  490.                       const char **var,
  491.                       const char *set_doc,
  492.                       const char *show_doc,
  493.                       const char *help_doc,
  494.                       cmd_sfunc_ftype *set_func,
  495.                       show_value_ftype *show_func,
  496.                       struct cmd_list_element **set_list,
  497.                       struct cmd_list_element **show_list)
  498. {
  499.   struct cmd_list_element *c;

  501.   add_setshow_cmd_full (name, class, var_enum, var,
  502.                         set_doc, show_doc, help_doc,
  503.                         set_func, show_func,
  504.                         set_list, show_list,
  505.                         &c, NULL);
  506.   c->enums = enumlist;
  507. }

  509. ‌const char * const auto_boolean_enums[] = { "on", "off", "auto", NULL };

  511. /* Add an auto-boolean command named NAME to both the set and show
  512.    command list lists.  CLASS is as in add_cmd.  VAR is address of the
  513.    variable which will contain the value.  DOC is the documentation
  514.    string.  FUNC is the corresponding callback.  */
  515. void
  516. ‌add_setshow_auto_boolean_cmd (const char *name,
  517.                               enum command_class class,
  518.                               enum auto_boolean *var,
  519.                               const char *set_doc, const char *show_doc,
  520.                               const char *help_doc,
  521.                               cmd_sfunc_ftype *set_func,
  522.                               show_value_ftype *show_func,
  523.                               struct cmd_list_element **set_list,
  524.                               struct cmd_list_element **show_list)
  525. {
  526.   struct cmd_list_element *c;

  528.   add_setshow_cmd_full (name, class, var_auto_boolean, var,
  529.                         set_doc, show_doc, help_doc,
  530.                         set_func, show_func,
  531.                         set_list, show_list,
  532.                         &c, NULL);
  533.   c->enums = auto_boolean_enums;
  534. }

  536. /* Add element named NAME to both the set and show command LISTs (the
  537.    list for set/show or some sublist thereof).  CLASS is as in
  538.    add_cmd.  VAR is address of the variable which will contain the
  539.    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
  540. void
  541. ‌add_setshow_boolean_cmd (const char *name, enum command_class class, int *var,
  542.                          const char *set_doc, const char *show_doc,
  543.                          const char *help_doc,
  544.                          cmd_sfunc_ftype *set_func,
  545.                          show_value_ftype *show_func,
  546.                          struct cmd_list_element **set_list,
  547.                          struct cmd_list_element **show_list)
  548. {
  549.   static const char *boolean_enums[] = { "on", "off", NULL };
  550.   struct cmd_list_element *c;

  552.   add_setshow_cmd_full (name, class, var_boolean, var,
  553.                         set_doc, show_doc, help_doc,
  554.                         set_func, show_func,
  555.                         set_list, show_list,
  556.                         &c, NULL);
  557.   c->enums = boolean_enums;
  558. }

  560. /* Add element named NAME to both the set and show command LISTs (the
  561.    list for set/show or some sublist thereof).  */
  562. void
  563. ‌add_setshow_filename_cmd (const char *name, enum command_class class,
  564.                           char **var,
  565.                           const char *set_doc, const char *show_doc,
  566.                           const char *help_doc,
  567.                           cmd_sfunc_ftype *set_func,
  568.                           show_value_ftype *show_func,
  569.                           struct cmd_list_element **set_list,
  570.                           struct cmd_list_element **show_list)
  571. {
  572.   struct cmd_list_element *set_result;

  574.   add_setshow_cmd_full (name, class, var_filename, var,
  575.                         set_doc, show_doc, help_doc,
  576.                         set_func, show_func,
  577.                         set_list, show_list,
  578.                         &set_result, NULL);
  579.   set_cmd_completer (set_result, filename_completer);
  580. }

  582. /* Add element named NAME to both the set and show command LISTs (the
  583.    list for set/show or some sublist thereof).  */
  584. void
  585. ‌add_setshow_string_cmd (const char *name, enum command_class class,
  586.                         char **var,
  587.                         const char *set_doc, const char *show_doc,
  588.                         const char *help_doc,
  589.                         cmd_sfunc_ftype *set_func,
  590.                         show_value_ftype *show_func,
  591.                         struct cmd_list_element **set_list,
  592.                         struct cmd_list_element **show_list)
  593. {
  594.   add_setshow_cmd_full (name, class, var_string, var,
  595.                         set_doc, show_doc, help_doc,
  596.                         set_func, show_func,
  597.                         set_list, show_list,
  598.                         NULL, NULL);
  599. }

  601. /* Add element named NAME to both the set and show command LISTs (the
  602.    list for set/show or some sublist thereof).  */
  603. struct cmd_list_element *
  604. ‌add_setshow_string_noescape_cmd (const char *name, enum command_class class,
  605.                                  char **var,
  606.                                  const char *set_doc, const char *show_doc,
  607.                                  const char *help_doc,
  608.                                  cmd_sfunc_ftype *set_func,
  609.                                  show_value_ftype *show_func,
  610.                                  struct cmd_list_element **set_list,
  611.                                  struct cmd_list_element **show_list)
  612. {
  613.   struct cmd_list_element *set_cmd;

  615.   add_setshow_cmd_full (name, class, var_string_noescape, var,
  616.                         set_doc, show_doc, help_doc,
  617.                         set_func, show_func,
  618.                         set_list, show_list,
  619.                         &set_cmd, NULL);
  620.   return set_cmd;
  621. }

  623. /* Add element named NAME to both the set and show command LISTs (the
  624.    list for set/show or some sublist thereof).  */
  625. void
  626. ‌add_setshow_optional_filename_cmd (const char *name, enum command_class class,
  627.                                    char **var,
  628.                                    const char *set_doc, const char *show_doc,
  629.                                    const char *help_doc,
  630.                                    cmd_sfunc_ftype *set_func,
  631.                                    show_value_ftype *show_func,
  632.                                    struct cmd_list_element **set_list,
  633.                                    struct cmd_list_element **show_list)
  634. {
  635.   struct cmd_list_element *set_result;

  637.   add_setshow_cmd_full (name, class, var_optional_filename, var,
  638.                         set_doc, show_doc, help_doc,
  639.                         set_func, show_func,
  640.                         set_list, show_list,
  641.                         &set_result, NULL);

  643.   set_cmd_completer (set_result, filename_completer);

  645. }

  647. /* Completes on literal "unlimited".  Used by integer commands that
  648.    support a special "unlimited" value.  */

  650. ‌static VEC (char_ptr) *
  651. integer_unlimited_completer (struct cmd_list_element *ignore,
  652.                              const char *text, const char *word)
  653. {
  654.   static const char * const keywords[] =
  655.     {
  656.       "unlimited",
  657.       NULL,
  658.     };

  660.   return complete_on_enum (keywords, text, word);
  661. }

  663. /* Add element named NAME to both the set and show command LISTs (the
  664.    list for set/show or some sublist thereof).  CLASS is as in
  665.    add_cmd.  VAR is address of the variable which will contain the
  666.    value.  SET_DOC and SHOW_DOC are the documentation strings.  This
  667.    function is only used in Python API.  Please don't use it elsewhere.  */
  668. void
  669. ‌add_setshow_integer_cmd (const char *name, enum command_class class,
  670.                          int *var,
  671.                          const char *set_doc, const char *show_doc,
  672.                          const char *help_doc,
  673.                          cmd_sfunc_ftype *set_func,
  674.                          show_value_ftype *show_func,
  675.                          struct cmd_list_element **set_list,
  676.                          struct cmd_list_element **show_list)
  677. {
  678.   struct cmd_list_element *set;

  680.   add_setshow_cmd_full (name, class, var_integer, var,
  681.                         set_doc, show_doc, help_doc,
  682.                         set_func, show_func,
  683.                         set_list, show_list,
  684.                         &set, NULL);

  686.   set_cmd_completer (set, integer_unlimited_completer);
  687. }

  689. /* Add element named NAME to both the set and show command LISTs (the
  690.    list for set/show or some sublist thereof).  CLASS is as in
  691.    add_cmd.  VAR is address of the variable which will contain the
  692.    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
  693. void
  694. ‌add_setshow_uinteger_cmd (const char *name, enum command_class class,
  695.                           unsigned int *var,
  696.                           const char *set_doc, const char *show_doc,
  697.                           const char *help_doc,
  698.                           cmd_sfunc_ftype *set_func,
  699.                           show_value_ftype *show_func,
  700.                           struct cmd_list_element **set_list,
  701.                           struct cmd_list_element **show_list)
  702. {
  703.   struct cmd_list_element *set;

  705.   add_setshow_cmd_full (name, class, var_uinteger, var,
  706.                         set_doc, show_doc, help_doc,
  707.                         set_func, show_func,
  708.                         set_list, show_list,
  709.                         &set, NULL);

  711.   set_cmd_completer (set, integer_unlimited_completer);
  712. }

  714. /* Add element named NAME to both the set and show command LISTs (the
  715.    list for set/show or some sublist thereof).  CLASS is as in
  716.    add_cmd.  VAR is address of the variable which will contain the
  717.    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
  718. void
  719. ‌add_setshow_zinteger_cmd (const char *name, enum command_class class,
  720.                           int *var,
  721.                           const char *set_doc, const char *show_doc,
  722.                           const char *help_doc,
  723.                           cmd_sfunc_ftype *set_func,
  724.                           show_value_ftype *show_func,
  725.                           struct cmd_list_element **set_list,
  726.                           struct cmd_list_element **show_list)
  727. {
  728.   add_setshow_cmd_full (name, class, var_zinteger, var,
  729.                         set_doc, show_doc, help_doc,
  730.                         set_func, show_func,
  731.                         set_list, show_list,
  732.                         NULL, NULL);
  733. }

  735. void
  736. ‌add_setshow_zuinteger_unlimited_cmd (const char *name,
  737.                                      enum command_class class,
  738.                                      int *var,
  739.                                      const char *set_doc,
  740.                                      const char *show_doc,
  741.                                      const char *help_doc,
  742.                                      cmd_sfunc_ftype *set_func,
  743.                                      show_value_ftype *show_func,
  744.                                      struct cmd_list_element **set_list,
  745.                                      struct cmd_list_element **show_list)
  746. {
  747.   struct cmd_list_element *set;

  749.   add_setshow_cmd_full (name, class, var_zuinteger_unlimited, var,
  750.                         set_doc, show_doc, help_doc,
  751.                         set_func, show_func,
  752.                         set_list, show_list,
  753.                         &set, NULL);

  755.   set_cmd_completer (set, integer_unlimited_completer);
  756. }

  758. /* Add element named NAME to both the set and show command LISTs (the
  759.    list for set/show or some sublist thereof).  CLASS is as in
  760.    add_cmd.  VAR is address of the variable which will contain the
  761.    value.  SET_DOC and SHOW_DOC are the documentation strings.  */
  762. void
  763. ‌add_setshow_zuinteger_cmd (const char *name, enum command_class class,
  764.                            unsigned int *var,
  765.                            const char *set_doc, const char *show_doc,
  766.                            const char *help_doc,
  767.                            cmd_sfunc_ftype *set_func,
  768.                            show_value_ftype *show_func,
  769.                            struct cmd_list_element **set_list,
  770.                            struct cmd_list_element **show_list)
  771. {
  772.   add_setshow_cmd_full (name, class, var_zuinteger, var,
  773.                         set_doc, show_doc, help_doc,
  774.                         set_func, show_func,
  775.                         set_list, show_list,
  776.                         NULL, NULL);
  777. }

  779. /* Remove the command named NAME from the command list.  Return the
  780.    list commands which were aliased to the deleted command.  If the
  781.    command had no aliases, return NULL.  The various *HOOKs are set to
  782.    the pre- and post-hook commands for the deleted command.  If the
  783.    command does not have a hook, the corresponding out parameter is
  784.    set to NULL.  */

  786. static struct cmd_list_element *
  787. ‌delete_cmd (const char *name, struct cmd_list_element **list,
  788.             struct cmd_list_element **prehook,
  789.             struct cmd_list_element **prehookee,
  790.             struct cmd_list_element **posthook,
  791.             struct cmd_list_element **posthookee)
  792. {
  793.   struct cmd_list_element *iter;
  794.   struct cmd_list_element **previous_chain_ptr;
  795.   struct cmd_list_element *aliases = NULL;

  797.   *prehook = NULL;
  798.   *prehookee = NULL;
  799.   *posthook = NULL;
  800.   *posthookee = NULL;
  801.   previous_chain_ptr = list;

  803.   for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr)
  804.     {
  805.       if (strcmp (iter->name, name) == 0)
  806.         {
  807.           if (iter->destroyer)
  808.             iter->destroyer (iter, iter->context);
  809.           if (iter->hookee_pre)
  810.             iter->hookee_pre->hook_pre = 0;
  811.           *prehook = iter->hook_pre;
  812.           *prehookee = iter->hookee_pre;
  813.           if (iter->hookee_post)
  814.             iter->hookee_post->hook_post = 0;
  815.           if (iter->doc && iter->doc_allocated)
  816.             xfree ((char *) iter->doc);
  817.           *posthook = iter->hook_post;
  818.           *posthookee = iter->hookee_post;

  820.           /* Update the link.  */
  821.           *previous_chain_ptr = iter->next;

  823.           aliases = iter->aliases;

  825.           /* If this command was an alias, remove it from the list of
  826.              aliases.  */
  827.           if (iter->cmd_pointer)
  828.             {
  829.               struct cmd_list_element **prevp = &iter->cmd_pointer->aliases;
  830.               struct cmd_list_element *a = *prevp;

  832.               while (a != iter)
  833.                 {
  834.                   prevp = &a->alias_chain;
  835.                   a = *prevp;
  836.                 }
  837.               *prevp = iter->alias_chain;
  838.             }

  840.           xfree (iter);

  842.           /* We won't see another command with the same name.  */
  843.           break;
  844.         }
  845.       else
  846.         previous_chain_ptr = &iter->next;
  847.     }

  849.   return aliases;
  850. }

  852. /* Shorthands to the commands above.  */

  854. /* Add an element to the list of info subcommands.  */

  856. struct cmd_list_element *
  857. ‌add_info (const char *name, cmd_cfunc_ftype *fun, const char *doc)
  858. {
  859.   return add_cmd (name, no_class, fun, doc, &infolist);
  860. }

  862. /* Add an alias to the list of info subcommands.  */

  864. struct cmd_list_element *
  865. ‌add_info_alias (const char *name, const char *oldname, int abbrev_flag)
  866. {
  867.   return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
  868. }

  870. /* Add an element to the list of commands.  */

  872. struct cmd_list_element *
  873. ‌add_com (const char *name, enum command_class class, cmd_cfunc_ftype *fun,
  874.          const char *doc)
  875. {
  876.   return add_cmd (name, class, fun, doc, &cmdlist);
  877. }

  879. /* Add an alias or abbreviation command to the list of commands.  */

  881. struct cmd_list_element *
  882. ‌add_com_alias (const char *name, const char *oldname, enum command_class class,
  883.                int abbrev_flag)
  884. {
  885.   return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
  886. }

  888. /* Recursively walk the commandlist structures, and print out the
  889.    documentation of commands that match our regex in either their
  890.    name, or their documentation.
  891. */
  892. void
  893. ‌apropos_cmd (struct ui_file *stream,
  894.              struct cmd_list_element *commandlist,
  895.              struct re_pattern_buffer *regex, const char *prefix)
  896. {
  897.   struct cmd_list_element *c;
  898.   int returnvalue;

  900.   /* Walk through the commands.  */
  901.   for (c=commandlist;c;c=c->next)
  902.     {
  903.       returnvalue = -1; /* Needed to avoid double printing.  */
  904.       if (c->name != NULL)
  905.         {
  906.           /* Try to match against the name.  */
  907.           returnvalue = re_search (regex, c->name, strlen(c->name),
  908.                                    0, strlen (c->name), NULL);
  909.           if (returnvalue >= 0)
  910.             {
  911.               print_help_for_command (c, prefix,
  912.                                       0 /* don't recurse */, stream);
  913.             }
  914.         }
  915.       if (c->doc != NULL && returnvalue < 0)
  916.         {
  917.           /* Try to match against documentation.  */
  918.           if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
  919.             {
  920.               print_help_for_command (c, prefix,
  921.                                       0 /* don't recurse */, stream);
  922.             }
  923.         }
  924.       /* Check if this command has subcommands and is not an
  925.          abbreviation.  We skip listing subcommands of abbreviations
  926.          in order to avoid duplicates in the output.  */
  927.       if (c->prefixlist != NULL && !c->abbrev_flag)
  928.         {
  929.           /* Recursively call ourselves on the subcommand list,
  930.              passing the right prefix in.  */
  931.           apropos_cmd (stream,*c->prefixlist,regex,c->prefixname);
  932.         }
  933.     }
  934. }

  936. /* This command really has to deal with two things:
  937.    1) I want documentation on *this string* (usually called by
  938.       "help commandname").

  940.    2) I want documentation on *this list* (usually called by giving a
  941.       command that requires subcommands.  Also called by saying just
  942.       "help".)

  944.    I am going to split this into two seperate comamnds, help_cmd and
  945.    help_list.  */

  947. void
  948. ‌help_cmd (const char *command, struct ui_file *stream)
  949. {
  950.   struct cmd_list_element *c;

  952.   if (!command)
  953.     {
  954.       help_list (cmdlist, "", all_classes, stream);
  955.       return;
  956.     }

  958.   if (strcmp (command, "all") == 0)
  959.     {
  960.       help_all (stream);
  961.       return;
  962.     }

  964.   c = lookup_cmd (&command, cmdlist, "", 0, 0);

  966.   if (c == 0)
  967.     return;

  969.   /* There are three cases here.
  970.      If c->prefixlist is nonzero, we have a prefix command.
  971.      Print its documentation, then list its subcommands.

  973.      If c->func is non NULL, we really have a command.  Print its
  974.      documentation and return.

  976.      If c->func is NULL, we have a class name.  Print its
  977.      documentation (as if it were a command) and then set class to the
  978.      number of this class so that the commands in the class will be
  979.      listed.  */

  981.   fputs_filtered (c->doc, stream);
  982.   fputs_filtered ("\n", stream);

  984.   if (c->prefixlist == 0 && c->func != NULL)
  985.     return;
  986.   fprintf_filtered (stream, "\n");

  988.   /* If this is a prefix command, print it's subcommands.  */
  989.   if (c->prefixlist)
  990.     help_list (*c->prefixlist, c->prefixname, all_commands, stream);

  992.   /* If this is a class name, print all of the commands in the class.  */
  993.   if (c->func == NULL)
  994.     help_list (cmdlist, "", c->class, stream);

  996.   if (c->hook_pre || c->hook_post)
  997.     fprintf_filtered (stream,
  998.                       "\nThis command has a hook (or hooks) defined:\n");

  1000.   if (c->hook_pre)
  1001.     fprintf_filtered (stream,
  1002.                       "\tThis command is run after  : %s (pre hook)\n",
  1003.                     c->hook_pre->name);
  1004.   if (c->hook_post)
  1005.     fprintf_filtered (stream,
  1006.                       "\tThis command is run before : %s (post hook)\n",
  1007.                     c->hook_post->name);
  1008. }

  1010. /*
  1011. * Get a specific kind of help on a command list.
  1012. *
  1013. * LIST is the list.
  1014. * CMDTYPE is the prefix to use in the title string.
  1015. * CLASS is the class with which to list the nodes of this list (see
  1016. * documentation for help_cmd_list below),  As usual, ALL_COMMANDS for
  1017. * everything, ALL_CLASSES for just classes, and non-negative for only things
  1018. * in a specific class.
  1019. * and STREAM is the output stream on which to print things.
  1020. * If you call this routine with a class >= 0, it recurses.
  1021. */
  1022. void
  1023. ‌help_list (struct cmd_list_element *list, const char *cmdtype,
  1024.            enum command_class class, struct ui_file *stream)
  1025. {
  1026.   int len;
  1027.   char *cmdtype1, *cmdtype2;

  1029.   /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub".
  1030.    */
  1031.   len = strlen (cmdtype);
  1032.   cmdtype1 = (char *) alloca (len + 1);
  1033.   cmdtype1[0] = 0;
  1034.   cmdtype2 = (char *) alloca (len + 4);
  1035.   cmdtype2[0] = 0;
  1036.   if (len)
  1037.     {
  1038.       cmdtype1[0] = ' ';
  1039.       strncpy (cmdtype1 + 1, cmdtype, len - 1);
  1040.       cmdtype1[len] = 0;
  1041.       strncpy (cmdtype2, cmdtype, len - 1);
  1042.       strcpy (cmdtype2 + len - 1, " sub");
  1043.     }

  1045.   if (class == all_classes)
  1046.     fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
  1047.   else
  1048.     fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);

  1050.   help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);

  1052.   if (class == all_classes)
  1053.     {
  1054.       fprintf_filtered (stream, "\n\
  1055. Type \"help%s\" followed by a class name for a list of commands in ",
  1056.                         cmdtype1);
  1057.       wrap_here ("");
  1058.       fprintf_filtered (stream, "that class.");

  1060.       fprintf_filtered (stream, "\n\
  1061. Type \"help all\" for the list of all commands.");
  1062.     }

  1064.   fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
  1065.                     cmdtype1, cmdtype2);
  1066.   wrap_here ("");
  1067.   fputs_filtered ("for ", stream);
  1068.   wrap_here ("");
  1069.   fputs_filtered ("full ", stream);
  1070.   wrap_here ("");
  1071.   fputs_filtered ("documentation.\n", stream);
  1072.   fputs_filtered ("Type \"apropos word\" to search "
  1073.                   "for commands related to \"word\".\n", stream);
  1074.   fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
  1075.                   stream);
  1076. }

  1078. static void
  1079. ‌help_all (struct ui_file *stream)
  1080. {
  1081.   struct cmd_list_element *c;
  1082.   int seen_unclassified = 0;

  1084.   for (c = cmdlist; c; c = c->next)
  1085.     {
  1086.       if (c->abbrev_flag)
  1087.         continue;
  1088.       /* If this is a class name, print all of the commands in the
  1089.          class.  */

  1091.       if (c->func == NULL)
  1092.         {
  1093.           fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
  1094.           help_cmd_list (cmdlist, c->class, "", 1, stream);
  1095.         }
  1096.     }

  1098.   /* While it's expected that all commands are in some class,
  1099.      as a safety measure, we'll print commands outside of any
  1100.      class at the end.  */

  1102.   for (c = cmdlist; c; c = c->next)
  1103.     {
  1104.       if (c->abbrev_flag)
  1105.         continue;

  1107.       if (c->class == no_class)
  1108.         {
  1109.           if (!seen_unclassified)
  1110.             {
  1111.               fprintf_filtered (stream, "\nUnclassified commands\n\n");
  1112.               seen_unclassified = 1;
  1113.             }
  1114.           print_help_for_command (c, "", 1, stream);
  1115.         }
  1116.     }

  1118. }

  1120. /* Print only the first line of STR on STREAM.  */
  1121. void
  1122. ‌print_doc_line (struct ui_file *stream, const char *str)
  1123. {
  1124.   static char *line_buffer = 0;
  1125.   static int line_size;
  1126.   const char *p;

  1128.   if (!line_buffer)
  1129.     {
  1130.       line_size = 80;
  1131.       line_buffer = (char *) xmalloc (line_size);
  1132.     }

  1134.   /* Keep printing '.' or ',' not followed by a whitespace for embedded strings
  1135.      like '.gdbinit'.  */
  1136.   p = str;
  1137.   while (*p && *p != '\n'
  1138.          && ((*p != '.' && *p != ',') || (p[1] && !isspace (p[1]))))
  1139.     p++;
  1140.   if (p - str > line_size - 1)
  1141.     {
  1142.       line_size = p - str + 1;
  1143.       xfree (line_buffer);
  1144.       line_buffer = (char *) xmalloc (line_size);
  1145.     }
  1146.   strncpy (line_buffer, str, p - str);
  1147.   line_buffer[p - str] = '\0';
  1148.   if (islower (line_buffer[0]))
  1149.     line_buffer[0] = toupper (line_buffer[0]);
  1150.   fputs_filtered (line_buffer, stream);
  1151. }

  1153. /* Print one-line help for command C.
  1154.    If RECURSE is non-zero, also print one-line descriptions
  1155.    of all prefixed subcommands.  */
  1156. static void
  1157. ‌print_help_for_command (struct cmd_list_element *c, const char *prefix,
  1158.                         int recurse, struct ui_file *stream)
  1159. {
  1160.   fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
  1161.   print_doc_line (stream, c->doc);
  1162.   fputs_filtered ("\n", stream);

  1164.   if (recurse
  1165.       && c->prefixlist != 0
  1166.       && c->abbrev_flag == 0)
  1167.     /* Subcommands of a prefix command typically have 'all_commands'
  1168.        as class.  If we pass CLASS to recursive invocation,
  1169.        most often we won't see anything.  */
  1170.     help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
  1171. }

  1173. /*
  1174. * Implement a help command on command list LIST.
  1175. * RECURSE should be non-zero if this should be done recursively on
  1176. * all sublists of LIST.
  1177. * PREFIX is the prefix to print before each command name.
  1178. * STREAM is the stream upon which the output should be written.
  1179. * CLASS should be:
  1180. *      A non-negative class number to list only commands in that
  1181. * class.
  1182. *      ALL_COMMANDS to list all commands in list.
  1183. *      ALL_CLASSES  to list all classes in list.
  1184. *
  1185. *   Note that RECURSE will be active on *all* sublists, not just the
  1186. * ones selected by the criteria above (ie. the selection mechanism
  1187. * is at the low level, not the high-level).
  1188. */
  1189. void
  1190. ‌help_cmd_list (struct cmd_list_element *list, enum command_class class,
  1191.                const char *prefix, int recurse, struct ui_file *stream)
  1192. {
  1193.   struct cmd_list_element *c;

  1195.   for (c = list; c; c = c->next)
  1196.     {
  1197.       if (c->abbrev_flag == 0
  1198.           && (class == all_commands
  1199.               || (class == all_classes && c->func == NULL)
  1200.               || (class == c->class && c->func != NULL)))
  1201.         {
  1202.           print_help_for_command (c, prefix, recurse, stream);
  1203.         }
  1204.       else if (c->abbrev_flag == 0 && recurse
  1205.                && class == class_user && c->prefixlist != NULL)
  1206.         /* User-defined commands may be subcommands.  */
  1207.         help_cmd_list (*c->prefixlist, class, c->prefixname,
  1208.                        recurse, stream);
  1209.     }
  1210. }


  1213. /* Search the input clist for 'command'.  Return the command if
  1214.    found (or NULL if not), and return the number of commands
  1215.    found in nfound.  */

  1217. static struct cmd_list_element *
  1218. ‌find_cmd (const char *command, int len, struct cmd_list_element *clist,
  1219.           int ignore_help_classes, int *nfound)
  1220. {
  1221.   struct cmd_list_element *found, *c;

  1223.   found = (struct cmd_list_element *) NULL;
  1224.   *nfound = 0;
  1225.   for (c = clist; c; c = c->next)
  1226.     if (!strncmp (command, c->name, len)
  1227.         && (!ignore_help_classes || c->func))
  1228.       {
  1229.         found = c;
  1230.         (*nfound)++;
  1231.         if (c->name[len] == '\0')
  1232.           {
  1233.             *nfound = 1;
  1234.             break;
  1235.           }
  1236.       }
  1237.   return found;
  1238. }

  1240. static int
  1241. ‌find_command_name_length (const char *text)
  1242. {
  1243.   const char *p = text;

  1245.   /* Treating underscores as part of command words is important
  1246.      so that "set args_foo()" doesn't get interpreted as
  1247.      "set args _foo()".  */
  1248.   /* Some characters are only used for TUI specific commands.
  1249.      However, they are always allowed for the sake of consistency.

  1251.      The XDB compatibility characters are only allowed when using the
  1252.      right mode because they clash with other GDB commands -
  1253.      specifically '/' is used as a suffix for print, examine and
  1254.      display.

  1256.      Note that this is larger than the character set allowed when
  1257.      creating user-defined commands.  */

  1259.   /* Recognize '!' as a single character command so that, e.g., "!ls"
  1260.      works as expected.  */
  1261.   if (*p == '!')
  1262.     return 1;

  1264.   while (isalnum (*p) || *p == '-' || *p == '_'
  1265.          /* Characters used by TUI specific commands.  */
  1266.          || *p == '+' || *p == '<' || *p == '>' || *p == '$'
  1267.          /* Characters used for XDB compatibility.  */
  1268.          || (xdb_commands && (*p == '/' || *p == '?')))
  1269.     p++;

  1271.   return p - text;
  1272. }

  1274. /* Return TRUE if NAME is a valid user-defined command name.
  1275.    This is a stricter subset of all gdb commands,
  1276.    see find_command_name_length.  */

  1278. int
  1279. ‌valid_user_defined_cmd_name_p (const char *name)
  1280. {
  1281.   const char *p;

  1283.   if (*name == '\0')
  1284.     return FALSE;

  1286.   /* Alas "42" is a legitimate user-defined command.
  1287.      In the interests of not breaking anything we preserve that.  */

  1289.   for (p = name; *p != '\0'; ++p)
  1290.     {
  1291.       if (isalnum (*p)
  1292.           || *p == '-'
  1293.           || *p == '_')
  1294.         ; /* Ok.  */
  1295.       else
  1296.         return FALSE;
  1297.     }

  1299.   return TRUE;
  1300. }

  1302. /* This routine takes a line of TEXT and a CLIST in which to start the
  1303.    lookup.  When it returns it will have incremented the text pointer past
  1304.    the section of text it matched, set *RESULT_LIST to point to the list in
  1305.    which the last word was matched, and will return a pointer to the cmd
  1306.    list element which the text matches.  It will return NULL if no match at
  1307.    all was possible.  It will return -1 (cast appropriately, ick) if ambigous
  1308.    matches are possible; in this case *RESULT_LIST will be set to point to
  1309.    the list in which there are ambiguous choices (and *TEXT will be set to
  1310.    the ambiguous text string).

  1312.    If the located command was an abbreviation, this routine returns the base
  1313.    command of the abbreviation.

  1315.    It does no error reporting whatsoever; control will always return
  1316.    to the superior routine.

  1318.    In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
  1319.    at the prefix_command (ie. the best match) *or* (special case) will be NULL
  1320.    if no prefix command was ever found.  For example, in the case of "info a",
  1321.    "info" matches without ambiguity, but "a" could be "args" or "address", so
  1322.    *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
  1323.    RESULT_LIST should not be interpeted as a pointer to the beginning of a
  1324.    list; it simply points to a specific command.  In the case of an ambiguous
  1325.    return *TEXT is advanced past the last non-ambiguous prefix (e.g.
  1326.    "info t" can be "info types" or "info target"; upon return *TEXT has been
  1327.    advanced past "info ").

  1329.    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
  1330.    affect the operation).

  1332.    This routine does *not* modify the text pointed to by TEXT.

  1334.    If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
  1335.    are actually help classes rather than commands (i.e. the function field of
  1336.    the struct cmd_list_element is NULL).  */

  1338. struct cmd_list_element *
  1339. ‌lookup_cmd_1 (const char **text, struct cmd_list_element *clist,
  1340.               struct cmd_list_element **result_list, int ignore_help_classes)
  1341. {
  1342.   char *command;
  1343.   int len, tmp, nfound;
  1344.   struct cmd_list_element *found, *c;
  1345.   const char *line = *text;

  1347.   while (**text == ' ' || **text == '\t')
  1348.     (*text)++;

  1350.   /* Identify the name of the command.  */
  1351.   len = find_command_name_length (*text);

  1353.   /* If nothing but whitespace, return 0.  */
  1354.   if (len == 0)
  1355.     return 0;

  1357.   /* *text and p now bracket the first command word to lookup (and
  1358.      it's length is len).  We copy this into a local temporary.  */


  1361.   command = (char *) alloca (len + 1);
  1362.   memcpy (command, *text, len);
  1363.   command[len] = '\0';

  1365.   /* Look it up.  */
  1366.   found = 0;
  1367.   nfound = 0;
  1368.   found = find_cmd (command, len, clist, ignore_help_classes, &nfound);

  1370.   /* We didn't find the command in the entered case, so lower case it
  1371.      and search again.  */
  1372.   if (!found || nfound == 0)
  1373.     {
  1374.       for (tmp = 0; tmp < len; tmp++)
  1375.         {
  1376.           char x = command[tmp];

  1378.           command[tmp] = isupper (x) ? tolower (x) : x;
  1379.         }
  1380.       found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
  1381.     }

  1383.   /* If nothing matches, we have a simple failure.  */
  1384.   if (nfound == 0)
  1385.     return 0;

  1387.   if (nfound > 1)
  1388.     {
  1389.       if (result_list != NULL)
  1390.         /* Will be modified in calling routine
  1391.            if we know what the prefix command is.  */
  1392.         *result_list = 0;
  1393.       return CMD_LIST_AMBIGUOUS;        /* Ambiguous.  */
  1394.     }

  1396.   /* We've matched something on this list.  Move text pointer forward.  */

  1398.   *text += len;

  1400.   if (found->cmd_pointer)
  1401.     {
  1402.       /* We drop the alias (abbreviation) in favor of the command it
  1403.        is pointing to.  If the alias is deprecated, though, we need to
  1404.        warn the user about it before we drop it.  Note that while we
  1405.        are warning about the alias, we may also warn about the command
  1406.        itself and we will adjust the appropriate DEPRECATED_WARN_USER
  1407.        flags.  */

  1409.       if (found->deprecated_warn_user)
  1410.         deprecated_cmd_warning (line);
  1411.       found = found->cmd_pointer;
  1412.     }
  1413.   /* If we found a prefix command, keep looking.  */

  1415.   if (found->prefixlist)
  1416.     {
  1417.       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
  1418.                         ignore_help_classes);
  1419.       if (!c)
  1420.         {
  1421.           /* Didn't find anything; this is as far as we got.  */
  1422.           if (result_list != NULL)
  1423.             *result_list = clist;
  1424.           return found;
  1425.         }
  1426.       else if (c == CMD_LIST_AMBIGUOUS)
  1427.         {
  1428.           /* We've gotten this far properly, but the next step is
  1429.              ambiguous.  We need to set the result list to the best
  1430.              we've found (if an inferior hasn't already set it).  */
  1431.           if (result_list != NULL)
  1432.             if (!*result_list)
  1433.               /* This used to say *result_list = *found->prefixlist.
  1434.                  If that was correct, need to modify the documentation
  1435.                  at the top of this function to clarify what is
  1436.                  supposed to be going on.  */
  1437.               *result_list = found;
  1438.           return c;
  1439.         }
  1440.       else
  1441.         {
  1442.           /* We matched!  */
  1443.           return c;
  1444.         }
  1445.     }
  1446.   else
  1447.     {
  1448.       if (result_list != NULL)
  1449.         *result_list = clist;
  1450.       return found;
  1451.     }
  1452. }

  1454. /* All this hair to move the space to the front of cmdtype */

  1456. static void
  1457. ‌undef_cmd_error (const char *cmdtype, const char *q)
  1458. {
  1459.   error (_("Undefined %scommand: \"%s\".  Try \"help%s%.*s\"."),
  1460.          cmdtype,
  1461.          q,
  1462.          *cmdtype ? " " : "",
  1463.          (int) strlen (cmdtype) - 1,
  1464.          cmdtype);
  1465. }

  1467. /* Look up the contents of *LINE as a command in the command list LIST.
  1468.    LIST is a chain of struct cmd_list_element's.
  1469.    If it is found, return the struct cmd_list_element for that command
  1470.    and update *LINE to point after the command name, at the first argument.
  1471.    If not found, call error if ALLOW_UNKNOWN is zero
  1472.    otherwise (or if error returns) return zero.
  1473.    Call error if specified command is ambiguous,
  1474.    unless ALLOW_UNKNOWN is negative.
  1475.    CMDTYPE precedes the word "command" in the error message.

  1477.    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
  1478.    elements which are actually help classes rather than commands (i.e.
  1479.    the function field of the struct cmd_list_element is 0).  */

  1481. struct cmd_list_element *
  1482. ‌lookup_cmd (const char **line, struct cmd_list_element *list, char *cmdtype,
  1483.             int allow_unknown, int ignore_help_classes)
  1484. {
  1485.   struct cmd_list_element *last_list = 0;
  1486.   struct cmd_list_element *c;

  1488.   /* Note: Do not remove trailing whitespace here because this
  1489.      would be wrong for complete_command.  Jim Kingdon  */

  1491.   if (!*line)
  1492.     error (_("Lack of needed %scommand"), cmdtype);

  1494.   c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);

  1496.   if (!c)
  1497.     {
  1498.       if (!allow_unknown)
  1499.         {
  1500.           char *q;
  1501.           int len = find_command_name_length (*line);

  1503.           q = (char *) alloca (len + 1);
  1504.           strncpy (q, *line, len);
  1505.           q[len] = '\0';
  1506.           undef_cmd_error (cmdtype, q);
  1507.         }
  1508.       else
  1509.         return 0;
  1510.     }
  1511.   else if (c == CMD_LIST_AMBIGUOUS)
  1512.     {
  1513.       /* Ambigous.  Local values should be off prefixlist or called
  1514.          values.  */
  1515.       int local_allow_unknown = (last_list ? last_list->allow_unknown :
  1516.                                  allow_unknown);
  1517.       const char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
  1518.       struct cmd_list_element *local_list =
  1519.         (last_list ? *(last_list->prefixlist) : list);

  1521.       if (local_allow_unknown < 0)
  1522.         {
  1523.           if (last_list)
  1524.             return last_list;        /* Found something.  */
  1525.           else
  1526.             return 0;                /* Found nothing.  */
  1527.         }
  1528.       else
  1529.         {
  1530.           /* Report as error.  */
  1531.           int amb_len;
  1532.           char ambbuf[100];

  1534.           for (amb_len = 0;
  1535.                ((*line)[amb_len] && (*line)[amb_len] != ' '
  1536.                 && (*line)[amb_len] != '\t');
  1537.                amb_len++)
  1538.             ;

  1540.           ambbuf[0] = 0;
  1541.           for (c = local_list; c; c = c->next)
  1542.             if (!strncmp (*line, c->name, amb_len))
  1543.               {
  1544.                 if (strlen (ambbuf) + strlen (c->name) + 6
  1545.                     < (int) sizeof ambbuf)
  1546.                   {
  1547.                     if (strlen (ambbuf))
  1548.                       strcat (ambbuf, ", ");
  1549.                     strcat (ambbuf, c->name);
  1550.                   }
  1551.                 else
  1552.                   {
  1553.                     strcat (ambbuf, "..");
  1554.                     break;
  1555.                   }
  1556.               }
  1557.           error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
  1558.                  *line, ambbuf);
  1559.           return 0;                /* lint */
  1560.         }
  1561.     }
  1562.   else
  1563.     {
  1564.       if (c->type == set_cmd && **line != '\0' && !isspace (**line))
  1565.         error (_("Argument must be preceded by space."));

  1567.       /* We've got something.  It may still not be what the caller
  1568.          wants (if this command *needs* a subcommand).  */
  1569.       while (**line == ' ' || **line == '\t')
  1570.         (*line)++;

  1572.       if (c->prefixlist && **line && !c->allow_unknown)
  1573.         undef_cmd_error (c->prefixname, *line);

  1575.       /* Seems to be what he wants.  Return it.  */
  1576.       return c;
  1577.     }
  1578.   return 0;
  1579. }

  1581. /* We are here presumably because an alias or command in TEXT is
  1582.    deprecated and a warning message should be generated.  This
  1583.    function decodes TEXT and potentially generates a warning message
  1584.    as outlined below.

  1586.    Example for 'set endian big' which has a fictitious alias 'seb'.

  1588.    If alias wasn't used in TEXT, and the command is deprecated:
  1589.    "warning: 'set endian big' is deprecated."

  1591.    If alias was used, and only the alias is deprecated:
  1592.    "warning: 'seb' an alias for the command 'set endian big' is deprecated."

  1594.    If alias was used and command is deprecated (regardless of whether
  1595.    the alias itself is deprecated:

  1597.    "warning: 'set endian big' (seb) is deprecated."

  1599.    After the message has been sent, clear the appropriate flags in the
  1600.    command and/or the alias so the user is no longer bothered.

  1602. */
  1603. void
  1604. ‌deprecated_cmd_warning (const char *text)
  1605. {
  1606.   struct cmd_list_element *alias = NULL;
  1607.   struct cmd_list_element *prefix_cmd = NULL;
  1608.   struct cmd_list_element *cmd = NULL;

  1610.   if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd))
  1611.     /* Return if text doesn't evaluate to a command.  */
  1612.     return;

  1614.   if (!((alias ? alias->deprecated_warn_user : 0)
  1615.       || cmd->deprecated_warn_user) )
  1616.     /* Return if nothing is deprecated.  */
  1617.     return;

  1619.   printf_filtered ("Warning:");

  1621.   if (alias && !cmd->cmd_deprecated)
  1622.     printf_filtered (" '%s', an alias for the", alias->name);

  1624.   printf_filtered (" command '");

  1626.   if (prefix_cmd)
  1627.     printf_filtered ("%s", prefix_cmd->prefixname);

  1629.   printf_filtered ("%s", cmd->name);

  1631.   if (alias && cmd->cmd_deprecated)
  1632.     printf_filtered ("' (%s) is deprecated.\n", alias->name);
  1633.   else
  1634.     printf_filtered ("' is deprecated.\n");


  1637.   /* If it is only the alias that is deprecated, we want to indicate
  1638.      the new alias, otherwise we'll indicate the new command.  */

  1640.   if (alias && !cmd->cmd_deprecated)
  1641.     {
  1642.       if (alias->replacement)
  1643.         printf_filtered ("Use '%s'.\n\n", alias->replacement);
  1644.       else
  1645.         printf_filtered ("No alternative known.\n\n");
  1646.      }
  1647.   else
  1648.     {
  1649.       if (cmd->replacement)
  1650.         printf_filtered ("Use '%s'.\n\n", cmd->replacement);
  1651.       else
  1652.         printf_filtered ("No alternative known.\n\n");
  1653.     }

  1655.   /* We've warned you, now we'll keep quiet.  */
  1656.   if (alias)
  1657.     alias->deprecated_warn_user = 0;

  1659.   cmd->deprecated_warn_user = 0;
  1660. }


  1663. /* Look up the contents of LINE as a command in the command list 'cmdlist'.
  1664.    Return 1 on success, 0 on failure.

  1666.    If LINE refers to an alias, *alias will point to that alias.

  1668.    If LINE is a postfix command (i.e. one that is preceded by a prefix
  1669.    command) set *prefix_cmd.

  1671.    Set *cmd to point to the command LINE indicates.

  1673.    If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not
  1674.    exist, they are NULL when we return.

  1676. */
  1677. int
  1678. ‌lookup_cmd_composition (const char *text,
  1679.                       struct cmd_list_element **alias,
  1680.                       struct cmd_list_element **prefix_cmd,
  1681.                       struct cmd_list_element **cmd)
  1682. {
  1683.   char *command;
  1684.   int len, tmp, nfound;
  1685.   struct cmd_list_element *cur_list;
  1686.   struct cmd_list_element *prev_cmd;

  1688.   *alias = NULL;
  1689.   *prefix_cmd = NULL;
  1690.   *cmd = NULL;

  1692.   cur_list = cmdlist;

  1694.   while (1)
  1695.     {
  1696.       /* Go through as many command lists as we need to,
  1697.          to find the command TEXT refers to.  */

  1699.       prev_cmd = *cmd;

  1701.       while (*text == ' ' || *text == '\t')
  1702.         (text)++;

  1704.       /* Identify the name of the command.  */
  1705.       len = find_command_name_length (text);

  1707.       /* If nothing but whitespace, return.  */
  1708.       if (len == 0)
  1709.         return 0;

  1711.       /* Text is the start of the first command word to lookup (and
  1712.          it's length is len).  We copy this into a local temporary.  */

  1714.       command = (char *) alloca (len + 1);
  1715.       memcpy (command, text, len);
  1716.       command[len] = '\0';

  1718.       /* Look it up.  */
  1719.       *cmd = 0;
  1720.       nfound = 0;
  1721.       *cmd = find_cmd (command, len, cur_list, 1, &nfound);

  1723.       /* We didn't find the command in the entered case, so lower case
  1724.          it and search again.
  1725.       */
  1726.       if (!*cmd || nfound == 0)
  1727.         {
  1728.           for (tmp = 0; tmp < len; tmp++)
  1729.             {
  1730.               char x = command[tmp];

  1732.               command[tmp] = isupper (x) ? tolower (x) : x;
  1733.             }
  1734.           *cmd = find_cmd (command, len, cur_list, 1, &nfound);
  1735.         }

  1737.       if (*cmd == CMD_LIST_AMBIGUOUS)
  1738.         {
  1739.           return 0;              /* ambiguous */
  1740.         }

  1742.       if (*cmd == NULL)
  1743.         return 0;                /* nothing found */
  1744.       else
  1745.         {
  1746.           if ((*cmd)->cmd_pointer)
  1747.             {
  1748.               /* cmd was actually an alias, we note that an alias was
  1749.                  used (by assigning *alais) and we set *cmd.  */
  1750.               *alias = *cmd;
  1751.               *cmd = (*cmd)->cmd_pointer;
  1752.             }
  1753.           *prefix_cmd = prev_cmd;
  1754.         }
  1755.       if ((*cmd)->prefixlist)
  1756.         cur_list = *(*cmd)->prefixlist;
  1757.       else
  1758.         return 1;

  1760.       text += len;
  1761.     }
  1762. }

  1764. /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */

  1766. /* Return a vector of char pointers which point to the different
  1767.    possible completions in LIST of TEXT.

  1769.    WORD points in the same buffer as TEXT, and completions should be
  1770.    returned relative to this position.  For example, suppose TEXT is
  1771.    "foo" and we want to complete to "foobar".  If WORD is "oo", return
  1772.    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */

  1774. ‌VEC (char_ptr) *
  1775. complete_on_cmdlist (struct cmd_list_element *list,
  1776.                      const char *text, const char *word,
  1777.                      int ignore_help_classes)
  1778. {
  1779.   struct cmd_list_element *ptr;
  1780.   VEC (char_ptr) *matchlist = NULL;
  1781.   int textlen = strlen (text);
  1782.   int pass;
  1783.   int saw_deprecated_match = 0;

  1785.   /* We do one or two passes.  In the first pass, we skip deprecated
  1786.      commands.  If we see no matching commands in the first pass, and
  1787.      if we did happen to see a matching deprecated command, we do
  1788.      another loop to collect those.  */
  1789.   for (pass = 0; matchlist == 0 && pass < 2; ++pass)
  1790.     {
  1791.       for (ptr = list; ptr; ptr = ptr->next)
  1792.         if (!strncmp (ptr->name, text, textlen)
  1793.             && !ptr->abbrev_flag
  1794.             && (!ignore_help_classes || ptr->func
  1795.                 || ptr->prefixlist))
  1796.           {
  1797.             char *match;

  1799.             if (pass == 0)
  1800.               {
  1801.                 if (ptr->cmd_deprecated)
  1802.                   {
  1803.                     saw_deprecated_match = 1;
  1804.                     continue;
  1805.                   }
  1806.               }

  1808.             match = (char *) xmalloc (strlen (word) + strlen (ptr->name) + 1);
  1809.             if (word == text)
  1810.               strcpy (match, ptr->name);
  1811.             else if (word > text)
  1812.               {
  1813.                 /* Return some portion of ptr->name.  */
  1814.                 strcpy (match, ptr->name + (word - text));
  1815.               }
  1816.             else
  1817.               {
  1818.                 /* Return some of text plus ptr->name.  */
  1819.                 strncpy (match, word, text - word);
  1820.                 match[text - word] = '\0';
  1821.                 strcat (match, ptr->name);
  1822.               }
  1823.             VEC_safe_push (char_ptr, matchlist, match);
  1824.           }
  1825.       /* If we saw no matching deprecated commands in the first pass,
  1826.          just bail out.  */
  1827.       if (!saw_deprecated_match)
  1828.         break;
  1829.     }

  1831.   return matchlist;
  1832. }

  1834. /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */

  1836. /* Return a vector of char pointers which point to the different
  1837.    possible completions in CMD of TEXT.

  1839.    WORD points in the same buffer as TEXT, and completions should be
  1840.    returned relative to this position.  For example, suppose TEXT is "foo"
  1841.    and we want to complete to "foobar".  If WORD is "oo", return
  1842.    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */

  1844. ‌VEC (char_ptr) *
  1845. complete_on_enum (const char *const *enumlist,
  1846.                   const char *text, const char *word)
  1847. {
  1848.   VEC (char_ptr) *matchlist = NULL;
  1849.   int textlen = strlen (text);
  1850.   int i;
  1851.   const char *name;

  1853.   for (i = 0; (name = enumlist[i]) != NULL; i++)
  1854.     if (strncmp (name, text, textlen) == 0)
  1855.       {
  1856.         char *match;

  1858.         match = (char *) xmalloc (strlen (word) + strlen (name) + 1);
  1859.         if (word == text)
  1860.           strcpy (match, name);
  1861.         else if (word > text)
  1862.           {
  1863.             /* Return some portion of name.  */
  1864.             strcpy (match, name + (word - text));
  1865.           }
  1866.         else
  1867.           {
  1868.             /* Return some of text plus name.  */
  1869.             strncpy (match, word, text - word);
  1870.             match[text - word] = '\0';
  1871.             strcat (match, name);
  1872.           }
  1873.         VEC_safe_push (char_ptr, matchlist, match);
  1874.       }

  1876.   return matchlist;
  1877. }


  1880. /* Check function pointer.  */
  1881. int
  1882. ‌cmd_func_p (struct cmd_list_element *cmd)
  1883. {
  1884.   return (cmd->func != NULL);
  1885. }


  1888. /* Call the command function.  */
  1889. void
  1890. ‌cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
  1891. {
  1892.   if (cmd_func_p (cmd))
  1893.     (*cmd->func) (cmd, args, from_tty);
  1894.   else
  1895.     error (_("Invalid command"));
  1896. }

  1898. int
  1899. ‌cli_user_command_p (struct cmd_list_element *cmd)
  1900. {
  1901.   return (cmd->class == class_user
  1902.           && (cmd->func == do_cfunc || cmd->func == do_sfunc));
  1903. }