gdb/cli/cli-setshow.c

   1 /* Handle set and show GDB commands.
   2
   3    Copyright (C) 2000-2014 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "defs.h"
  19 #include "readline/tilde.h"
  20 #include "value.h"
  21 #include <ctype.h>
  22 #include <string.h>
  23 #include "arch-utils.h"
  24 #include "observer.h"
  25
  26 #include "ui-out.h"
  27
  28 #include "cli/cli-decode.h"
  29 #include "cli/cli-cmds.h"
  30 #include "cli/cli-setshow.h"
  31 #include "cli/cli-utils.h"
  32
  33 /* Return true if the change of command parameter should be notified.  */
  34
  35 static int
  36 notify_command_param_changed_p (int param_changed, struct cmd_list_element *c)
  37 {
  38   if (param_changed == 0)
  39     return 0;
  40
  41   if (c->class == class_maintenance || c->class == class_deprecated
  42       || c->class == class_obscure)
  43     return 0;
  44
  45   return 1;
  46 }
  47
  48 \f
  49 static enum auto_boolean
  50 parse_auto_binary_operation (const char *arg)
  51 {
  52   if (arg != NULL && *arg != '\0')
  53     {
  54       int length = strlen (arg);
  55
  56       while (isspace (arg[length - 1]) && length > 0)
  57         length--;
  58       if (strncmp (arg, "on", length) == 0
  59           || strncmp (arg, "1", length) == 0
  60           || strncmp (arg, "yes", length) == 0
  61           || strncmp (arg, "enable", length) == 0)
  62         return AUTO_BOOLEAN_TRUE;
  63       else if (strncmp (arg, "off", length) == 0
  64                || strncmp (arg, "0", length) == 0
  65                || strncmp (arg, "no", length) == 0
  66                || strncmp (arg, "disable", length) == 0)
  67         return AUTO_BOOLEAN_FALSE;
  68       else if (strncmp (arg, "auto", length) == 0
  69                || (strncmp (arg, "-1", length) == 0 && length > 1))
  70         return AUTO_BOOLEAN_AUTO;
  71     }
  72   error (_("\"on\", \"off\" or \"auto\" expected."));
  73   return AUTO_BOOLEAN_AUTO; /* Pacify GCC.  */
  74 }
  75
  76 /* See cli-setshow.h.  */
  77
  78 int
  79 parse_cli_boolean_value (const char *arg)
  80 {
  81   int length;
  82
  83   if (!arg || !*arg)
  84     return 1;
  85
  86   length = strlen (arg);
  87
  88   while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
  89     length--;
  90
  91   if (strncmp (arg, "on", length) == 0
  92       || strncmp (arg, "1", length) == 0
  93       || strncmp (arg, "yes", length) == 0
  94       || strncmp (arg, "enable", length) == 0)
  95     return 1;
  96   else if (strncmp (arg, "off", length) == 0
  97            || strncmp (arg, "0", length) == 0
  98            || strncmp (arg, "no", length) == 0
  99            || strncmp (arg, "disable", length) == 0)
 100     return 0;
 101   else
 102     return -1;
 103 }
 104 \f
 105 void
 106 deprecated_show_value_hack (struct ui_file *ignore_file,
 107                             int ignore_from_tty,
 108                             struct cmd_list_element *c,
 109                             const char *value)
 110 {
 111   /* If there's no command or value, don't try to print it out.  */
 112   if (c == NULL || value == NULL)
 113     return;
 114   /* Print doc minus "show" at start.  */
 115   print_doc_line (gdb_stdout, c->doc + 5);
 116   switch (c->var_type)
 117     {
 118     case var_string:
 119     case var_string_noescape:
 120     case var_optional_filename:
 121     case var_filename:
 122     case var_enum:
 123       printf_filtered ((" is \"%s\".\n"), value);
 124       break;
 125     default:
 126       printf_filtered ((" is %s.\n"), value);
 127       break;
 128     }
 129 }
 130
 131 /* Returns true if ARG is "unlimited".  */
 132
 133 static int
 134 is_unlimited_literal (const char *arg)
 135 {
 136   size_t len = sizeof ("unlimited") - 1;
 137
 138   arg = skip_spaces_const (arg);
 139
 140   return (strncmp (arg, "unlimited", len) == 0
 141           && (isspace (arg[len]) || arg[len] == '\0'));
 142 }
 143
 144
 145 /* Do a "set" command.  ARG is NULL if no argument, or the
 146    text of the argument, and FROM_TTY is nonzero if this command is
 147    being entered directly by the user (i.e. these are just like any
 148    other command).  C is the command list element for the command.  */
 149
 150 void
 151 do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
 152 {
 153   /* A flag to indicate the option is changed or not.  */
 154   int option_changed = 0;
 155
 156   gdb_assert (c->type == set_cmd);
 157
 158   switch (c->var_type)
 159     {
 160     case var_string:
 161       {
 162         char *new;
 163         const char *p;
 164         char *q;
 165         int ch;
 166
 167         if (arg == NULL)
 168           arg = "";
 169         new = (char *) xmalloc (strlen (arg) + 2);
 170         p = arg;
 171         q = new;
 172         while ((ch = *p++) != '\000')
 173           {
 174             if (ch == '\\')
 175               {
 176                 /* \ at end of argument is used after spaces
 177                    so they won't be lost.  */
 178                 /* This is obsolete now that we no longer strip
 179                    trailing whitespace and actually, the backslash
 180                    didn't get here in my test, readline or
 181                    something did something funky with a backslash
 182                    right before a newline.  */
 183                 if (*p == 0)
 184                   break;
 185                 ch = parse_escape (get_current_arch (), &p);
 186                 if (ch == 0)
 187                   break;        /* C loses */
 188                 else if (ch > 0)
 189                   *q++ = ch;
 190               }
 191             else
 192               *q++ = ch;
 193           }
 194 #if 0
 195         if (*(p - 1) != '\\')
 196           *q++ = ' ';
 197 #endif
 198         *q++ = '\0';
 199         new = (char *) xrealloc (new, q - new);
 200
 201         if (*(char **) c->var == NULL
 202             || strcmp (*(char **) c->var, new) != 0)
 203           {
 204             xfree (*(char **) c->var);
 205             *(char **) c->var = new;
 206
 207             option_changed = 1;
 208           }
 209         else
 210           xfree (new);
 211       }
 212       break;
 213     case var_string_noescape:
 214       if (arg == NULL)
 215         arg = "";
 216
 217       if (*(char **) c->var == NULL || strcmp (*(char **) c->var, arg) != 0)
 218         {
 219           xfree (*(char **) c->var);
 220           *(char **) c->var = xstrdup (arg);
 221
 222           option_changed = 1;
 223         }
 224       break;
 225     case var_filename:
 226       if (arg == NULL)
 227         error_no_arg (_("filename to set it to."));
 228       /* FALLTHROUGH */
 229     case var_optional_filename:
 230       {
 231         char *val = NULL;
 232
 233         if (arg != NULL)
 234           {
 235             /* Clear trailing whitespace of filename.  */
 236             const char *ptr = arg + strlen (arg) - 1;
 237             char *copy;
 238
 239             while (ptr >= arg && (*ptr == ' ' || *ptr == '\t'))
 240               ptr--;
 241             copy = xstrndup (arg, ptr + 1 - arg);
 242
 243             val = tilde_expand (copy);
 244             xfree (copy);
 245           }
 246         else
 247           val = xstrdup ("");
 248
 249         if (*(char **) c->var == NULL
 250             || strcmp (*(char **) c->var, val) != 0)
 251           {
 252             xfree (*(char **) c->var);
 253             *(char **) c->var = val;
 254
 255             option_changed = 1;
 256           }
 257         else
 258           xfree (val);
 259       }
 260       break;
 261     case var_boolean:
 262       {
 263         int val = parse_cli_boolean_value (arg);
 264
 265         if (val < 0)
 266           error (_("\"on\" or \"off\" expected."));
 267         if (val != *(int *) c->var)
 268           {
 269             *(int *) c->var = val;
 270
 271             option_changed = 1;
 272           }
 273       }
 274       break;
 275     case var_auto_boolean:
 276       {
 277         enum auto_boolean val = parse_auto_binary_operation (arg);
 278
 279         if (*(enum auto_boolean *) c->var != val)
 280           {
 281             *(enum auto_boolean *) c->var = val;
 282
 283             option_changed = 1;
 284           }
 285       }
 286       break;
 287     case var_uinteger:
 288     case var_zuinteger:
 289       {
 290         LONGEST val;
 291
 292         if (arg == NULL)
 293           {
 294             if (c->var_type == var_uinteger)
 295               error_no_arg (_("integer to set it to, or \"unlimited\"."));
 296             else
 297               error_no_arg (_("integer to set it to."));
 298           }
 299
 300         if (c->var_type == var_uinteger && is_unlimited_literal (arg))
 301           val = 0;
 302         else
 303           val = parse_and_eval_long (arg);
 304
 305         if (c->var_type == var_uinteger && val == 0)
 306           val = UINT_MAX;
 307         else if (val < 0
 308                  /* For var_uinteger, don't let the user set the value
 309                     to UINT_MAX directly, as that exposes an
 310                     implementation detail to the user interface.  */
 311                  || (c->var_type == var_uinteger && val >= UINT_MAX)
 312                  || (c->var_type == var_zuinteger && val > UINT_MAX))
 313           error (_("integer %s out of range"), plongest (val));
 314
 315         if (*(unsigned int *) c->var != val)
 316           {
 317             *(unsigned int *) c->var = val;
 318
 319             option_changed = 1;
 320           }
 321       }
 322       break;
 323     case var_integer:
 324     case var_zinteger:
 325       {
 326         LONGEST val;
 327
 328         if (arg == NULL)
 329           {
 330             if (c->var_type == var_integer)
 331               error_no_arg (_("integer to set it to, or \"unlimited\"."));
 332             else
 333               error_no_arg (_("integer to set it to."));
 334           }
 335
 336         if (c->var_type == var_integer && is_unlimited_literal (arg))
 337           val = 0;
 338         else
 339           val = parse_and_eval_long (arg);
 340
 341         if (val == 0 && c->var_type == var_integer)
 342           val = INT_MAX;
 343         else if (val < INT_MIN
 344                  /* For var_integer, don't let the user set the value
 345                     to INT_MAX directly, as that exposes an
 346                     implementation detail to the user interface.  */
 347                  || (c->var_type == var_integer && val >= INT_MAX)
 348                  || (c->var_type == var_zinteger && val > INT_MAX))
 349           error (_("integer %s out of range"), plongest (val));
 350
 351         if (*(int *) c->var != val)
 352           {
 353             *(int *) c->var = val;
 354
 355             option_changed = 1;
 356           }
 357         break;
 358       }
 359     case var_enum:
 360       {
 361         int i;
 362         int len;
 363         int nmatches;
 364         const char *match = NULL;
 365         char *p;
 366
 367         /* If no argument was supplied, print an informative error
 368            message.  */
 369         if (arg == NULL)
 370           {
 371             char *msg;
 372             int msg_len = 0;
 373
 374             for (i = 0; c->enums[i]; i++)
 375               msg_len += strlen (c->enums[i]) + 2;
 376
 377             msg = xmalloc (msg_len);
 378             *msg = '\0';
 379             make_cleanup (xfree, msg);
 380
 381             for (i = 0; c->enums[i]; i++)
 382               {
 383                 if (i != 0)
 384                   strcat (msg, ", ");
 385                 strcat (msg, c->enums[i]);
 386               }
 387             error (_("Requires an argument. Valid arguments are %s."),
 388                    msg);
 389           }
 390
 391         p = strchr (arg, ' ');
 392
 393         if (p)
 394           len = p - arg;
 395         else
 396           len = strlen (arg);
 397
 398         nmatches = 0;
 399         for (i = 0; c->enums[i]; i++)
 400           if (strncmp (arg, c->enums[i], len) == 0)
 401             {
 402               if (c->enums[i][len] == '\0')
 403                 {
 404                   match = c->enums[i];
 405                   nmatches = 1;
 406                   break; /* Exact match.  */
 407                 }
 408               else
 409                 {
 410                   match = c->enums[i];
 411                   nmatches++;
 412                 }
 413             }
 414
 415         if (nmatches <= 0)
 416           error (_("Undefined item: \"%s\"."), arg);
 417
 418         if (nmatches > 1)
 419           error (_("Ambiguous item \"%s\"."), arg);
 420
 421         if (*(const char **) c->var != match)
 422           {
 423             *(const char **) c->var = match;
 424
 425             option_changed = 1;
 426           }
 427       }
 428       break;
 429     case var_zuinteger_unlimited:
 430       {
 431         LONGEST val;
 432
 433         if (arg == NULL)
 434           error_no_arg (_("integer to set it to, or \"unlimited\"."));
 435
 436         if (is_unlimited_literal (arg))
 437           val = -1;
 438         else
 439           val = parse_and_eval_long (arg);
 440
 441         if (val > INT_MAX)
 442           error (_("integer %s out of range"), plongest (val));
 443         else if (val < -1)
 444           error (_("only -1 is allowed to set as unlimited"));
 445
 446         if (*(int *) c->var != val)
 447           {
 448             *(int *) c->var = val;
 449             option_changed = 1;
 450           }
 451       }
 452       break;
 453     default:
 454       error (_("gdb internal error: bad var_type in do_setshow_command"));
 455     }
 456   c->func (c, NULL, from_tty);
 457
 458   if (notify_command_param_changed_p (option_changed, c))
 459     {
 460       char *name, *cp;
 461       struct cmd_list_element **cmds;
 462       struct cmd_list_element *p;
 463       int i;
 464       int length = 0;
 465
 466       /* Compute the whole multi-word command options.  If user types command
 467          'set foo bar baz on', c->name is 'baz', and GDB can't pass "bar" to
 468          command option change notification, because it is confusing.  We can
 469          trace back through field 'prefix' to compute the whole options,
 470          and pass "foo bar baz" to notification.  */
 471
 472       for (i = 0, p = c; p != NULL; i++)
 473         {
 474           length += strlen (p->name);
 475           length++;
 476
 477           p = p->prefix;
 478         }
 479       cp = name = xmalloc (length);
 480       cmds = xmalloc (sizeof (struct cmd_list_element *) * i);
 481
 482       /* Track back through filed 'prefix' and cache them in CMDS.  */
 483       for (i = 0, p = c; p != NULL; i++)
 484         {
 485           cmds[i] = p;
 486           p = p->prefix;
 487         }
 488
 489       /* Don't trigger any observer notification if prefixlist is not
 490          setlist.  */
 491       i--;
 492       if (cmds[i]->prefixlist != &setlist)
 493         {
 494           xfree (cmds);
 495           xfree (name);
 496
 497           return;
 498         }
 499       /* Traverse them in the reversed order, and copy their names into
 500          NAME.  */
 501       for (i--; i >= 0; i--)
 502         {
 503           memcpy (cp, cmds[i]->name, strlen (cmds[i]->name));
 504           cp += strlen (cmds[i]->name);
 505
 506           if (i != 0)
 507             {
 508               cp[0] = ' ';
 509               cp++;
 510             }
 511         }
 512       cp[0] = 0;
 513
 514       xfree (cmds);
 515
 516       switch (c->var_type)
 517         {
 518         case var_string:
 519         case var_string_noescape:
 520         case var_filename:
 521         case var_optional_filename:
 522         case var_enum:
 523           observer_notify_command_param_changed (name, *(char **) c->var);
 524           break;
 525         case var_boolean:
 526           {
 527             char *opt = *(int *) c->var ? "on" : "off";
 528
 529             observer_notify_command_param_changed (name, opt);
 530           }
 531           break;
 532         case var_auto_boolean:
 533           {
 534             const char *s = auto_boolean_enums[*(enum auto_boolean *) c->var];
 535
 536             observer_notify_command_param_changed (name, s);
 537           }
 538           break;
 539         case var_uinteger:
 540         case var_zuinteger:
 541           {
 542             char s[64];
 543
 544             xsnprintf (s, sizeof s, "%u", *(unsigned int *) c->var);
 545             observer_notify_command_param_changed (name, s);
 546           }
 547           break;
 548         case var_integer:
 549         case var_zinteger:
 550         case var_zuinteger_unlimited:
 551           {
 552             char s[64];
 553
 554             xsnprintf (s, sizeof s, "%d", *(int *) c->var);
 555             observer_notify_command_param_changed (name, s);
 556           }
 557           break;
 558         }
 559       xfree (name);
 560     }
 561 }
 562
 563 /* Do a "show" command.  ARG is NULL if no argument, or the
 564    text of the argument, and FROM_TTY is nonzero if this command is
 565    being entered directly by the user (i.e. these are just like any
 566    other command).  C is the command list element for the command.  */
 567
 568 void
 569 do_show_command (const char *arg, int from_tty, struct cmd_list_element *c)
 570 {
 571   struct ui_out *uiout = current_uiout;
 572   struct cleanup *old_chain;
 573   struct ui_file *stb;
 574
 575   gdb_assert (c->type == show_cmd);
 576
 577   stb = mem_fileopen ();
 578   old_chain = make_cleanup_ui_file_delete (stb);
 579
 580   /* Possibly call the pre hook.  */
 581   if (c->pre_show_hook)
 582     (c->pre_show_hook) (c);
 583
 584   switch (c->var_type)
 585     {
 586     case var_string:
 587       if (*(char **) c->var)
 588         fputstr_filtered (*(char **) c->var, '"', stb);
 589       break;
 590     case var_string_noescape:
 591     case var_optional_filename:
 592     case var_filename:
 593     case var_enum:
 594       if (*(char **) c->var)
 595         fputs_filtered (*(char **) c->var, stb);
 596       break;
 597     case var_boolean:
 598       fputs_filtered (*(int *) c->var ? "on" : "off", stb);
 599       break;
 600     case var_auto_boolean:
 601       switch (*(enum auto_boolean*) c->var)
 602         {
 603         case AUTO_BOOLEAN_TRUE:
 604           fputs_filtered ("on", stb);
 605           break;
 606         case AUTO_BOOLEAN_FALSE:
 607           fputs_filtered ("off", stb);
 608           break;
 609         case AUTO_BOOLEAN_AUTO:
 610           fputs_filtered ("auto", stb);
 611           break;
 612         default:
 613           internal_error (__FILE__, __LINE__,
 614                           _("do_show_command: "
 615                             "invalid var_auto_boolean"));
 616           break;
 617         }
 618       break;
 619     case var_uinteger:
 620     case var_zuinteger:
 621       if (c->var_type == var_uinteger
 622           && *(unsigned int *) c->var == UINT_MAX)
 623         fputs_filtered ("unlimited", stb);
 624       else
 625         fprintf_filtered (stb, "%u", *(unsigned int *) c->var);
 626       break;
 627     case var_integer:
 628     case var_zinteger:
 629       if (c->var_type == var_integer
 630           && *(int *) c->var == INT_MAX)
 631         fputs_filtered ("unlimited", stb);
 632       else
 633         fprintf_filtered (stb, "%d", *(int *) c->var);
 634       break;
 635     case var_zuinteger_unlimited:
 636       {
 637         if (*(int *) c->var == -1)
 638           fputs_filtered ("unlimited", stb);
 639         else
 640           fprintf_filtered (stb, "%d", *(int *) c->var);
 641       }
 642       break;
 643     default:
 644       error (_("gdb internal error: bad var_type in do_show_command"));
 645     }
 646
 647
 648   /* FIXME: cagney/2005-02-10: Need to split this in half: code to
 649      convert the value into a string (esentially the above); and
 650      code to print the value out.  For the latter there should be
 651      MI and CLI specific versions.  */
 652
 653   if (ui_out_is_mi_like_p (uiout))
 654     ui_out_field_stream (uiout, "value", stb);
 655   else
 656     {
 657       char *value = ui_file_xstrdup (stb, NULL);
 658
 659       make_cleanup (xfree, value);
 660       if (c->show_value_func != NULL)
 661         c->show_value_func (gdb_stdout, from_tty, c, value);
 662       else
 663         deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
 664     }
 665   do_cleanups (old_chain);
 666
 667   c->func (c, NULL, from_tty);
 668 }
 669
 670 /* Show all the settings in a list of show commands.  */
 671
 672 void
 673 cmd_show_list (struct cmd_list_element *list, int from_tty, char *prefix)
 674 {
 675   struct cleanup *showlist_chain;
 676   struct ui_out *uiout = current_uiout;
 677
 678   showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
 679   for (; list != NULL; list = list->next)
 680     {
 681       /* If we find a prefix, run its list, prefixing our output by its
 682          prefix (with "show " skipped).  */
 683       if (list->prefixlist && !list->abbrev_flag)
 684         {
 685           struct cleanup *optionlist_chain
 686             = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
 687           char *new_prefix = strstr (list->prefixname, "show ") + 5;
 688
 689           if (ui_out_is_mi_like_p (uiout))
 690             ui_out_field_string (uiout, "prefix", new_prefix);
 691           cmd_show_list (*list->prefixlist, from_tty, new_prefix);
 692           /* Close the tuple.  */
 693           do_cleanups (optionlist_chain);
 694         }
 695       else
 696         {
 697           if (list->class != no_set_class)
 698             {
 699               struct cleanup *option_chain
 700                 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
 701
 702               ui_out_text (uiout, prefix);
 703               ui_out_field_string (uiout, "name", list->name);
 704               ui_out_text (uiout, ":  ");
 705               if (list->type == show_cmd)
 706                 do_show_command ((char *) NULL, from_tty, list);
 707               else
 708                 cmd_func (list, NULL, from_tty);
 709               /* Close the tuple.  */
 710               do_cleanups (option_chain);
 711             }
 712         }
 713     }
 714   /* Close the tuple.  */
 715   do_cleanups (showlist_chain);
 716 }
 717