gdb/cli/cli-setshow.c - gdb

Functions defined

Source code

  1. /* Handle set and show GDB commands.

  3.    Copyright (C) 2000-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 "readline/tilde.h"
  20. #include "value.h"
  21. #include <ctype.h>
  22. #include "arch-utils.h"
  23. #include "observer.h"

  25. #include "ui-out.h"

  27. #include "cli/cli-decode.h"
  28. #include "cli/cli-cmds.h"
  29. #include "cli/cli-setshow.h"
  30. #include "cli/cli-utils.h"

  32. /* Return true if the change of command parameter should be notified.  */

  34. static int
  35. ‌notify_command_param_changed_p (int param_changed, struct cmd_list_element *c)
  36. {
  37.   if (param_changed == 0)
  38.     return 0;

  40.   if (c->class == class_maintenance || c->class == class_deprecated
  41.       || c->class == class_obscure)
  42.     return 0;

  44.   return 1;
  45. }


  48. static enum auto_boolean
  49. ‌parse_auto_binary_operation (const char *arg)
  50. {
  51.   if (arg != NULL && *arg != '\0')
  52.     {
  53.       int length = strlen (arg);

  55.       while (isspace (arg[length - 1]) && length > 0)
  56.         length--;
  57.       if (strncmp (arg, "on", length) == 0
  58.           || strncmp (arg, "1", length) == 0
  59.           || strncmp (arg, "yes", length) == 0
  60.           || strncmp (arg, "enable", length) == 0)
  61.         return AUTO_BOOLEAN_TRUE;
  62.       else if (strncmp (arg, "off", length) == 0
  63.                || strncmp (arg, "0", length) == 0
  64.                || strncmp (arg, "no", length) == 0
  65.                || strncmp (arg, "disable", length) == 0)
  66.         return AUTO_BOOLEAN_FALSE;
  67.       else if (strncmp (arg, "auto", length) == 0
  68.                || (strncmp (arg, "-1", length) == 0 && length > 1))
  69.         return AUTO_BOOLEAN_AUTO;
  70.     }
  71.   error (_("\"on\", \"off\" or \"auto\" expected."));
  72.   return AUTO_BOOLEAN_AUTO; /* Pacify GCC.  */
  73. }

  75. /* See cli-setshow.h.  */

  77. int
  78. ‌parse_cli_boolean_value (const char *arg)
  79. {
  80.   int length;

  82.   if (!arg || !*arg)
  83.     return 1;

  85.   length = strlen (arg);

  87.   while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
  88.     length--;

  90.   if (strncmp (arg, "on", length) == 0
  91.       || strncmp (arg, "1", length) == 0
  92.       || strncmp (arg, "yes", length) == 0
  93.       || strncmp (arg, "enable", length) == 0)
  94.     return 1;
  95.   else if (strncmp (arg, "off", length) == 0
  96.            || strncmp (arg, "0", length) == 0
  97.            || strncmp (arg, "no", length) == 0
  98.            || strncmp (arg, "disable", length) == 0)
  99.     return 0;
  100.   else
  101.     return -1;
  102. }

  104. void
  105. ‌deprecated_show_value_hack (struct ui_file *ignore_file,
  106.                             int ignore_from_tty,
  107.                             struct cmd_list_element *c,
  108.                             const char *value)
  109. {
  110.   /* If there's no command or value, don't try to print it out.  */
  111.   if (c == NULL || value == NULL)
  112.     return;
  113.   /* Print doc minus "show" at start.  */
  114.   print_doc_line (gdb_stdout, c->doc + 5);
  115.   switch (c->var_type)
  116.     {
  117.     case var_string:
  118.     case var_string_noescape:
  119.     case var_optional_filename:
  120.     case var_filename:
  121.     case var_enum:
  122.       printf_filtered ((" is \"%s\".\n"), value);
  123.       break;
  124.     default:
  125.       printf_filtered ((" is %s.\n"), value);
  126.       break;
  127.     }
  128. }

  130. /* Returns true if ARG is "unlimited".  */

  132. static int
  133. ‌is_unlimited_literal (const char *arg)
  134. {
  135.   size_t len = sizeof ("unlimited") - 1;

  137.   arg = skip_spaces_const (arg);

  139.   return (strncmp (arg, "unlimited", len) == 0
  140.           && (isspace (arg[len]) || arg[len] == '\0'));
  141. }


  144. /* Do a "set" command.  ARG is NULL if no argument, or the
  145.    text of the argument, and FROM_TTY is nonzero if this command is
  146.    being entered directly by the user (i.e. these are just like any
  147.    other command).  C is the command list element for the command.  */

  149. void
  150. ‌do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
  151. {
  152.   /* A flag to indicate the option is changed or not.  */
  153.   int option_changed = 0;

  155.   gdb_assert (c->type == set_cmd);

  157.   switch (c->var_type)
  158.     {
  159.     case var_string:
  160.       {
  161.         char *new;
  162.         const char *p;
  163.         char *q;
  164.         int ch;

  166.         if (arg == NULL)
  167.           arg = "";
  168.         new = (char *) xmalloc (strlen (arg) + 2);
  169.         p = arg;
  170.         q = new;
  171.         while ((ch = *p++) != '\000')
  172.           {
  173.             if (ch == '\\')
  174.               {
  175.                 /* \ at end of argument is used after spaces
  176.                    so they won't be lost.  */
  177.                 /* This is obsolete now that we no longer strip
  178.                    trailing whitespace and actually, the backslash
  179.                    didn't get here in my test, readline or
  180.                    something did something funky with a backslash
  181.                    right before a newline.  */
  182.                 if (*p == 0)
  183.                   break;
  184.                 ch = parse_escape (get_current_arch (), &p);
  185.                 if (ch == 0)
  186.                   break;        /* C loses */
  187.                 else if (ch > 0)
  188.                   *q++ = ch;
  189.               }
  190.             else
  191.               *q++ = ch;
  192.           }
  193. #if 0
  194.         if (*(p - 1) != '\\')
  195.           *q++ = ' ';
  196. #endif
  197.         *q++ = '\0';
  198.         new = (char *) xrealloc (new, q - new);

  200.         if (*(char **) c->var == NULL
  201.             || strcmp (*(char **) c->var, new) != 0)
  202.           {
  203.             xfree (*(char **) c->var);
  204.             *(char **) c->var = new;

  206.             option_changed = 1;
  207.           }
  208.         else
  209.           xfree (new);
  210.       }
  211.       break;
  212.     case var_string_noescape:
  213.       if (arg == NULL)
  214.         arg = "";

  216.       if (*(char **) c->var == NULL || strcmp (*(char **) c->var, arg) != 0)
  217.         {
  218.           xfree (*(char **) c->var);
  219.           *(char **) c->var = xstrdup (arg);

  221.           option_changed = 1;
  222.         }
  223.       break;
  224.     case var_filename:
  225.       if (arg == NULL)
  226.         error_no_arg (_("filename to set it to."));
  227.       /* FALLTHROUGH */
  228.     case var_optional_filename:
  229.       {
  230.         char *val = NULL;

  232.         if (arg != NULL)
  233.           {
  234.             /* Clear trailing whitespace of filename.  */
  235.             const char *ptr = arg + strlen (arg) - 1;
  236.             char *copy;

  238.             while (ptr >= arg && (*ptr == ' ' || *ptr == '\t'))
  239.               ptr--;
  240.             copy = xstrndup (arg, ptr + 1 - arg);

  242.             val = tilde_expand (copy);
  243.             xfree (copy);
  244.           }
  245.         else
  246.           val = xstrdup ("");

  248.         if (*(char **) c->var == NULL
  249.             || strcmp (*(char **) c->var, val) != 0)
  250.           {
  251.             xfree (*(char **) c->var);
  252.             *(char **) c->var = val;

  254.             option_changed = 1;
  255.           }
  256.         else
  257.           xfree (val);
  258.       }
  259.       break;
  260.     case var_boolean:
  261.       {
  262.         int val = parse_cli_boolean_value (arg);

  264.         if (val < 0)
  265.           error (_("\"on\" or \"off\" expected."));
  266.         if (val != *(int *) c->var)
  267.           {
  268.             *(int *) c->var = val;

  270.             option_changed = 1;
  271.           }
  272.       }
  273.       break;
  274.     case var_auto_boolean:
  275.       {
  276.         enum auto_boolean val = parse_auto_binary_operation (arg);

  278.         if (*(enum auto_boolean *) c->var != val)
  279.           {
  280.             *(enum auto_boolean *) c->var = val;

  282.             option_changed = 1;
  283.           }
  284.       }
  285.       break;
  286.     case var_uinteger:
  287.     case var_zuinteger:
  288.       {
  289.         LONGEST val;

  291.         if (arg == NULL)
  292.           {
  293.             if (c->var_type == var_uinteger)
  294.               error_no_arg (_("integer to set it to, or \"unlimited\"."));
  295.             else
  296.               error_no_arg (_("integer to set it to."));
  297.           }

  299.         if (c->var_type == var_uinteger && is_unlimited_literal (arg))
  300.           val = 0;
  301.         else
  302.           val = parse_and_eval_long (arg);

  304.         if (c->var_type == var_uinteger && val == 0)
  305.           val = UINT_MAX;
  306.         else if (val < 0
  307.                  /* For var_uinteger, don't let the user set the value
  308.                     to UINT_MAX directly, as that exposes an
  309.                     implementation detail to the user interface.  */
  310.                  || (c->var_type == var_uinteger && val >= UINT_MAX)
  311.                  || (c->var_type == var_zuinteger && val > UINT_MAX))
  312.           error (_("integer %s out of range"), plongest (val));

  314.         if (*(unsigned int *) c->var != val)
  315.           {
  316.             *(unsigned int *) c->var = val;

  318.             option_changed = 1;
  319.           }
  320.       }
  321.       break;
  322.     case var_integer:
  323.     case var_zinteger:
  324.       {
  325.         LONGEST val;

  327.         if (arg == NULL)
  328.           {
  329.             if (c->var_type == var_integer)
  330.               error_no_arg (_("integer to set it to, or \"unlimited\"."));
  331.             else
  332.               error_no_arg (_("integer to set it to."));
  333.           }

  335.         if (c->var_type == var_integer && is_unlimited_literal (arg))
  336.           val = 0;
  337.         else
  338.           val = parse_and_eval_long (arg);

  340.         if (val == 0 && c->var_type == var_integer)
  341.           val = INT_MAX;
  342.         else if (val < INT_MIN
  343.                  /* For var_integer, don't let the user set the value
  344.                     to INT_MAX directly, as that exposes an
  345.                     implementation detail to the user interface.  */
  346.                  || (c->var_type == var_integer && val >= INT_MAX)
  347.                  || (c->var_type == var_zinteger && val > INT_MAX))
  348.           error (_("integer %s out of range"), plongest (val));

  350.         if (*(int *) c->var != val)
  351.           {
  352.             *(int *) c->var = val;

  354.             option_changed = 1;
  355.           }
  356.         break;
  357.       }
  358.     case var_enum:
  359.       {
  360.         int i;
  361.         int len;
  362.         int nmatches;
  363.         const char *match = NULL;
  364.         char *p;

  366.         /* If no argument was supplied, print an informative error
  367.            message.  */
  368.         if (arg == NULL)
  369.           {
  370.             char *msg;
  371.             int msg_len = 0;

  373.             for (i = 0; c->enums[i]; i++)
  374.               msg_len += strlen (c->enums[i]) + 2;

  376.             msg = xmalloc (msg_len);
  377.             *msg = '\0';
  378.             make_cleanup (xfree, msg);

  380.             for (i = 0; c->enums[i]; i++)
  381.               {
  382.                 if (i != 0)
  383.                   strcat (msg, ", ");
  384.                 strcat (msg, c->enums[i]);
  385.               }
  386.             error (_("Requires an argument. Valid arguments are %s."),
  387.                    msg);
  388.           }

  390.         p = strchr (arg, ' ');

  392.         if (p)
  393.           len = p - arg;
  394.         else
  395.           len = strlen (arg);

  397.         nmatches = 0;
  398.         for (i = 0; c->enums[i]; i++)
  399.           if (strncmp (arg, c->enums[i], len) == 0)
  400.             {
  401.               if (c->enums[i][len] == '\0')
  402.                 {
  403.                   match = c->enums[i];
  404.                   nmatches = 1;
  405.                   break; /* Exact match.  */
  406.                 }
  407.               else
  408.                 {
  409.                   match = c->enums[i];
  410.                   nmatches++;
  411.                 }
  412.             }

  414.         if (nmatches <= 0)
  415.           error (_("Undefined item: \"%s\"."), arg);

  417.         if (nmatches > 1)
  418.           error (_("Ambiguous item \"%s\"."), arg);

  420.         if (*(const char **) c->var != match)
  421.           {
  422.             *(const char **) c->var = match;

  424.             option_changed = 1;
  425.           }
  426.       }
  427.       break;
  428.     case var_zuinteger_unlimited:
  429.       {
  430.         LONGEST val;

  432.         if (arg == NULL)
  433.           error_no_arg (_("integer to set it to, or \"unlimited\"."));

  435.         if (is_unlimited_literal (arg))
  436.           val = -1;
  437.         else
  438.           val = parse_and_eval_long (arg);

  440.         if (val > INT_MAX)
  441.           error (_("integer %s out of range"), plongest (val));
  442.         else if (val < -1)
  443.           error (_("only -1 is allowed to set as unlimited"));

  445.         if (*(int *) c->var != val)
  446.           {
  447.             *(int *) c->var = val;
  448.             option_changed = 1;
  449.           }
  450.       }
  451.       break;
  452.     default:
  453.       error (_("gdb internal error: bad var_type in do_setshow_command"));
  454.     }
  455.   c->func (c, NULL, from_tty);

  457.   if (notify_command_param_changed_p (option_changed, c))
  458.     {
  459.       char *name, *cp;
  460.       struct cmd_list_element **cmds;
  461.       struct cmd_list_element *p;
  462.       int i;
  463.       int length = 0;

  465.       /* Compute the whole multi-word command options.  If user types command
  466.          'set foo bar baz on', c->name is 'baz', and GDB can't pass "bar" to
  467.          command option change notification, because it is confusing.  We can
  468.          trace back through field 'prefix' to compute the whole options,
  469.          and pass "foo bar baz" to notification.  */

  471.       for (i = 0, p = c; p != NULL; i++)
  472.         {
  473.           length += strlen (p->name);
  474.           length++;

  476.           p = p->prefix;
  477.         }
  478.       cp = name = xmalloc (length);
  479.       cmds = xmalloc (sizeof (struct cmd_list_element *) * i);

  481.       /* Track back through filed 'prefix' and cache them in CMDS.  */
  482.       for (i = 0, p = c; p != NULL; i++)
  483.         {
  484.           cmds[i] = p;
  485.           p = p->prefix;
  486.         }

  488.       /* Don't trigger any observer notification if prefixlist is not
  489.          setlist.  */
  490.       i--;
  491.       if (cmds[i]->prefixlist != &setlist)
  492.         {
  493.           xfree (cmds);
  494.           xfree (name);

  496.           return;
  497.         }
  498.       /* Traverse them in the reversed order, and copy their names into
  499.          NAME.  */
  500.       for (i--; i >= 0; i--)
  501.         {
  502.           memcpy (cp, cmds[i]->name, strlen (cmds[i]->name));
  503.           cp += strlen (cmds[i]->name);

  505.           if (i != 0)
  506.             {
  507.               cp[0] = ' ';
  508.               cp++;
  509.             }
  510.         }
  511.       cp[0] = 0;

  513.       xfree (cmds);

  515.       switch (c->var_type)
  516.         {
  517.         case var_string:
  518.         case var_string_noescape:
  519.         case var_filename:
  520.         case var_optional_filename:
  521.         case var_enum:
  522.           observer_notify_command_param_changed (name, *(char **) c->var);
  523.           break;
  524.         case var_boolean:
  525.           {
  526.             char *opt = *(int *) c->var ? "on" : "off";

  528.             observer_notify_command_param_changed (name, opt);
  529.           }
  530.           break;
  531.         case var_auto_boolean:
  532.           {
  533.             const char *s = auto_boolean_enums[*(enum auto_boolean *) c->var];

  535.             observer_notify_command_param_changed (name, s);
  536.           }
  537.           break;
  538.         case var_uinteger:
  539.         case var_zuinteger:
  540.           {
  541.             char s[64];

  543.             xsnprintf (s, sizeof s, "%u", *(unsigned int *) c->var);
  544.             observer_notify_command_param_changed (name, s);
  545.           }
  546.           break;
  547.         case var_integer:
  548.         case var_zinteger:
  549.         case var_zuinteger_unlimited:
  550.           {
  551.             char s[64];

  553.             xsnprintf (s, sizeof s, "%d", *(int *) c->var);
  554.             observer_notify_command_param_changed (name, s);
  555.           }
  556.           break;
  557.         }
  558.       xfree (name);
  559.     }
  560. }

  562. /* Do a "show" command.  ARG is NULL if no argument, or the
  563.    text of the argument, and FROM_TTY is nonzero if this command is
  564.    being entered directly by the user (i.e. these are just like any
  565.    other command).  C is the command list element for the command.  */

  567. void
  568. ‌do_show_command (const char *arg, int from_tty, struct cmd_list_element *c)
  569. {
  570.   struct ui_out *uiout = current_uiout;
  571.   struct cleanup *old_chain;
  572.   struct ui_file *stb;

  574.   gdb_assert (c->type == show_cmd);

  576.   stb = mem_fileopen ();
  577.   old_chain = make_cleanup_ui_file_delete (stb);

  579.   /* Possibly call the pre hook.  */
  580.   if (c->pre_show_hook)
  581.     (c->pre_show_hook) (c);

  583.   switch (c->var_type)
  584.     {
  585.     case var_string:
  586.       if (*(char **) c->var)
  587.         fputstr_filtered (*(char **) c->var, '"', stb);
  588.       break;
  589.     case var_string_noescape:
  590.     case var_optional_filename:
  591.     case var_filename:
  592.     case var_enum:
  593.       if (*(char **) c->var)
  594.         fputs_filtered (*(char **) c->var, stb);
  595.       break;
  596.     case var_boolean:
  597.       fputs_filtered (*(int *) c->var ? "on" : "off", stb);
  598.       break;
  599.     case var_auto_boolean:
  600.       switch (*(enum auto_boolean*) c->var)
  601.         {
  602.         case AUTO_BOOLEAN_TRUE:
  603.           fputs_filtered ("on", stb);
  604.           break;
  605.         case AUTO_BOOLEAN_FALSE:
  606.           fputs_filtered ("off", stb);
  607.           break;
  608.         case AUTO_BOOLEAN_AUTO:
  609.           fputs_filtered ("auto", stb);
  610.           break;
  611.         default:
  612.           internal_error (__FILE__, __LINE__,
  613.                           _("do_show_command: "
  614.                             "invalid var_auto_boolean"));
  615.           break;
  616.         }
  617.       break;
  618.     case var_uinteger:
  619.     case var_zuinteger:
  620.       if (c->var_type == var_uinteger
  621.           && *(unsigned int *) c->var == UINT_MAX)
  622.         fputs_filtered ("unlimited", stb);
  623.       else
  624.         fprintf_filtered (stb, "%u", *(unsigned int *) c->var);
  625.       break;
  626.     case var_integer:
  627.     case var_zinteger:
  628.       if (c->var_type == var_integer
  629.           && *(int *) c->var == INT_MAX)
  630.         fputs_filtered ("unlimited", stb);
  631.       else
  632.         fprintf_filtered (stb, "%d", *(int *) c->var);
  633.       break;
  634.     case var_zuinteger_unlimited:
  635.       {
  636.         if (*(int *) c->var == -1)
  637.           fputs_filtered ("unlimited", stb);
  638.         else
  639.           fprintf_filtered (stb, "%d", *(int *) c->var);
  640.       }
  641.       break;
  642.     default:
  643.       error (_("gdb internal error: bad var_type in do_show_command"));
  644.     }


  647.   /* FIXME: cagney/2005-02-10: Need to split this in half: code to
  648.      convert the value into a string (esentially the above); and
  649.      code to print the value out.  For the latter there should be
  650.      MI and CLI specific versions.  */

  652.   if (ui_out_is_mi_like_p (uiout))
  653.     ui_out_field_stream (uiout, "value", stb);
  654.   else
  655.     {
  656.       char *value = ui_file_xstrdup (stb, NULL);

  658.       make_cleanup (xfree, value);
  659.       if (c->show_value_func != NULL)
  660.         c->show_value_func (gdb_stdout, from_tty, c, value);
  661.       else
  662.         deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
  663.     }
  664.   do_cleanups (old_chain);

  666.   c->func (c, NULL, from_tty);
  667. }

  669. /* Show all the settings in a list of show commands.  */

  671. void
  672. ‌cmd_show_list (struct cmd_list_element *list, int from_tty, const char *prefix)
  673. {
  674.   struct cleanup *showlist_chain;
  675.   struct ui_out *uiout = current_uiout;

  677.   showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
  678.   for (; list != NULL; list = list->next)
  679.     {
  680.       /* If we find a prefix, run its list, prefixing our output by its
  681.          prefix (with "show " skipped).  */
  682.       if (list->prefixlist && !list->abbrev_flag)
  683.         {
  684.           struct cleanup *optionlist_chain
  685.             = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
  686.           char *new_prefix = strstr (list->prefixname, "show ") + 5;

  688.           if (ui_out_is_mi_like_p (uiout))
  689.             ui_out_field_string (uiout, "prefix", new_prefix);
  690.           cmd_show_list (*list->prefixlist, from_tty, new_prefix);
  691.           /* Close the tuple.  */
  692.           do_cleanups (optionlist_chain);
  693.         }
  694.       else
  695.         {
  696.           if (list->class != no_set_class)
  697.             {
  698.               struct cleanup *option_chain
  699.                 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");

  701.               ui_out_text (uiout, prefix);
  702.               ui_out_field_string (uiout, "name", list->name);
  703.               ui_out_text (uiout, ":  ");
  704.               if (list->type == show_cmd)
  705.                 do_show_command ((char *) NULL, from_tty, list);
  706.               else
  707.                 cmd_func (list, NULL, from_tty);
  708.               /* Close the tuple.  */
  709.               do_cleanups (option_chain);
  710.             }
  711.         }
  712.     }
  713.   /* Close the tuple.  */
  714.   do_cleanups (showlist_chain);
  715. }