gdb/cli/cli-setshow.c

   1 /* Handle set and show GDB commands.
   2
   3    Copyright (C) 2000-2017 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 "arch-utils.h"
  23 #include "observer.h"
  24
  25 #include "ui-out.h"
  26
  27 #include "cli/cli-decode.h"
  28 #include "cli/cli-cmds.h"
  29 #include "cli/cli-setshow.h"
  30 #include "cli/cli-utils.h"
  31
  32 /* Return true if the change of command parameter should be notified.  */
  33
  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;
  39
  40   if (c->theclass == class_maintenance || c->theclass == class_deprecated
  41       || c->theclass == class_obscure)
  42     return 0;
  43
  44   return 1;
  45 }
  46
  47 \f
  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);
  54
  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 }
  74
  75 /* See cli-setshow.h.  */
  76
  77 int
  78 parse_cli_boolean_value (const char *arg)
  79 {
  80   int length;
  81
  82   if (!arg || !*arg)
  83     return 1;
  84
  85   length = strlen (arg);
  86
  87   while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
  88     length--;
  89
  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 }
 103 \f
 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 }
 129
 130 /* Returns true if ARG is "unlimited".  */
 131
 132 static int
 133 is_unlimited_literal (const char *arg)
 134 {
 135   size_t len = sizeof ("unlimited") - 1;
 136
 137   arg = skip_spaces_const (arg);
 138
 139   return (strncmp (arg, "unlimited", len) == 0
 140           && (isspace (arg[len]) || arg[len] == '\0'));
 141 }
 142
 143
 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.  */
 148
 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;
 154
 155   gdb_assert (c->type == set_cmd);
 156
 157   switch (c->var_type)
 158     {
 159     case var_string:
 160       {
 161         char *newobj;
 162         const char *p;
 163         char *q;
 164         int ch;
 165
 166         if (arg == NULL)
 167           arg = "";
 168         newobj = (char *) xmalloc (strlen (arg) + 2);
 169         p = arg;
 170         q = newobj;
 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         newobj = (char *) xrealloc (newobj, q - newobj);
 199
 200         if (*(char **) c->var == NULL
 201             || strcmp (*(char **) c->var, newobj) != 0)
 202           {
 203             xfree (*(char **) c->var);
 204             *(char **) c->var = newobj;
 205
 206             option_changed = 1;
 207           }
 208         else
 209           xfree (newobj);
 210       }
 211       break;
 212     case var_string_noescape:
 213       if (arg == NULL)
 214         arg = "";
 215
 216       if (*(char **) c->var == NULL || strcmp (*(char **) c->var, arg) != 0)
 217         {
 218           xfree (*(char **) c->var);
 219           *(char **) c->var = xstrdup (arg);
 220
 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;
 231
 232         if (arg != NULL)
 233           {
 234             /* Clear trailing whitespace of filename.  */
 235             const char *ptr = arg + strlen (arg) - 1;
 236             char *copy;
 237
 238             while (ptr >= arg && (*ptr == ' ' || *ptr == '\t'))
 239               ptr--;
 240             copy = xstrndup (arg, ptr + 1 - arg);
 241
 242             val = tilde_expand (copy);
 243             xfree (copy);
 244           }
 245         else
 246           val = xstrdup ("");
 247
 248         if (*(char **) c->var == NULL
 249             || strcmp (*(char **) c->var, val) != 0)
 250           {
 251             xfree (*(char **) c->var);
 252             *(char **) c->var = val;
 253
 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);
 263
 264         if (val < 0)
 265           error (_("\"on\" or \"off\" expected."));
 266         if (val != *(int *) c->var)
 267           {
 268             *(int *) c->var = val;
 269
 270             option_changed = 1;
 271           }
 272       }
 273       break;
 274     case var_auto_boolean:
 275       {
 276         enum auto_boolean val = parse_auto_binary_operation (arg);
 277
 278         if (*(enum auto_boolean *) c->var != val)
 279           {
 280             *(enum auto_boolean *) c->var = val;
 281
 282             option_changed = 1;
 283           }
 284       }
 285       break;
 286     case var_uinteger:
 287     case var_zuinteger:
 288       {
 289         LONGEST val;
 290
 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           }
 298
 299         if (c->var_type == var_uinteger && is_unlimited_literal (arg))
 300           val = 0;
 301         else
 302           val = parse_and_eval_long (arg);
 303
 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));
 313
 314         if (*(unsigned int *) c->var != val)
 315           {
 316             *(unsigned int *) c->var = val;
 317
 318             option_changed = 1;
 319           }
 320       }
 321       break;
 322     case var_integer:
 323     case var_zinteger:
 324       {
 325         LONGEST val;
 326
 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           }
 334
 335         if (c->var_type == var_integer && is_unlimited_literal (arg))
 336           val = 0;
 337         else
 338           val = parse_and_eval_long (arg);
 339
 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));
 349
 350         if (*(int *) c->var != val)
 351           {
 352             *(int *) c->var = val;
 353
 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         const char *p;
 365
 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;
 372
 373             for (i = 0; c->enums[i]; i++)
 374               msg_len += strlen (c->enums[i]) + 2;
 375
 376             msg = (char *) xmalloc (msg_len);
 377             *msg = '\0';
 378             make_cleanup (xfree, msg);
 379
 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           }
 389
 390         p = strchr (arg, ' ');
 391
 392         if (p)
 393           len = p - arg;
 394         else
 395           len = strlen (arg);
 396
 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             }
 413
 414         if (nmatches <= 0)
 415           error (_("Undefined item: \"%s\"."), arg);
 416
 417         if (nmatches > 1)
 418           error (_("Ambiguous item \"%s\"."), arg);
 419
 420         if (*(const char **) c->var != match)
 421           {
 422             *(const char **) c->var = match;
 423
 424             option_changed = 1;
 425           }
 426       }
 427       break;
 428     case var_zuinteger_unlimited:
 429       {
 430         LONGEST val;
 431
 432         if (arg == NULL)
 433           error_no_arg (_("integer to set it to, or \"unlimited\"."));
 434
 435         if (is_unlimited_literal (arg))
 436           val = -1;
 437         else
 438           val = parse_and_eval_long (arg);
 439
 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"));
 444
 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);
 456
 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;
 464
 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.  */
 470
 471       for (i = 0, p = c; p != NULL; i++)
 472         {
 473           length += strlen (p->name);
 474           length++;
 475
 476           p = p->prefix;
 477         }
 478       cp = name = (char *) xmalloc (length);
 479       cmds = XNEWVEC (struct cmd_list_element *, i);
 480
 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         }
 487
 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);
 495
 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);
 504
 505           if (i != 0)
 506             {
 507               cp[0] = ' ';
 508               cp++;
 509             }
 510         }
 511       cp[0] = 0;
 512
 513       xfree (cmds);
 514
 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             const char *opt = *(int *) c->var ? "on" : "off";
 527
 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];
 534
 535             observer_notify_command_param_changed (name, s);
 536           }
 537           break;
 538         case var_uinteger:
 539         case var_zuinteger:
 540           {
 541             char s[64];
 542
 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];
 552
 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 }
 561
 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.  */
 566
 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
 572   gdb_assert (c->type == show_cmd);
 573
 574   string_file stb;
 575
 576   /* Possibly call the pre hook.  */
 577   if (c->pre_show_hook)
 578     (c->pre_show_hook) (c);
 579
 580   switch (c->var_type)
 581     {
 582     case var_string:
 583       if (*(char **) c->var)
 584         stb.putstr (*(char **) c->var, '"');
 585       break;
 586     case var_string_noescape:
 587     case var_optional_filename:
 588     case var_filename:
 589     case var_enum:
 590       if (*(char **) c->var)
 591         stb.puts (*(char **) c->var);
 592       break;
 593     case var_boolean:
 594       stb.puts (*(int *) c->var ? "on" : "off");
 595       break;
 596     case var_auto_boolean:
 597       switch (*(enum auto_boolean*) c->var)
 598         {
 599         case AUTO_BOOLEAN_TRUE:
 600           stb.puts ("on");
 601           break;
 602         case AUTO_BOOLEAN_FALSE:
 603           stb.puts ("off");
 604           break;
 605         case AUTO_BOOLEAN_AUTO:
 606           stb.puts ("auto");
 607           break;
 608         default:
 609           internal_error (__FILE__, __LINE__,
 610                           _("do_show_command: "
 611                             "invalid var_auto_boolean"));
 612           break;
 613         }
 614       break;
 615     case var_uinteger:
 616     case var_zuinteger:
 617       if (c->var_type == var_uinteger
 618           && *(unsigned int *) c->var == UINT_MAX)
 619         stb.puts ("unlimited");
 620       else
 621         stb.printf ("%u", *(unsigned int *) c->var);
 622       break;
 623     case var_integer:
 624     case var_zinteger:
 625       if (c->var_type == var_integer
 626           && *(int *) c->var == INT_MAX)
 627         stb.puts ("unlimited");
 628       else
 629         stb.printf ("%d", *(int *) c->var);
 630       break;
 631     case var_zuinteger_unlimited:
 632       {
 633         if (*(int *) c->var == -1)
 634           stb.puts ("unlimited");
 635         else
 636           stb.printf ("%d", *(int *) c->var);
 637       }
 638       break;
 639     default:
 640       error (_("gdb internal error: bad var_type in do_show_command"));
 641     }
 642
 643
 644   /* FIXME: cagney/2005-02-10: Need to split this in half: code to
 645      convert the value into a string (esentially the above); and
 646      code to print the value out.  For the latter there should be
 647      MI and CLI specific versions.  */
 648
 649   if (uiout->is_mi_like_p ())
 650     uiout->field_stream ("value", stb);
 651   else
 652     {
 653       if (c->show_value_func != NULL)
 654         c->show_value_func (gdb_stdout, from_tty, c, stb.c_str ());
 655       else
 656         deprecated_show_value_hack (gdb_stdout, from_tty, c, stb.c_str ());
 657     }
 658
 659   c->func (c, NULL, from_tty);
 660 }
 661
 662 /* Show all the settings in a list of show commands.  */
 663
 664 void
 665 cmd_show_list (struct cmd_list_element *list, int from_tty, const char *prefix)
 666 {
 667   struct ui_out *uiout = current_uiout;
 668
 669   ui_out_emit_tuple tuple_emitter (uiout, "showlist");
 670   for (; list != NULL; list = list->next)
 671     {
 672       /* If we find a prefix, run its list, prefixing our output by its
 673          prefix (with "show " skipped).  */
 674       if (list->prefixlist && !list->abbrev_flag)
 675         {
 676           ui_out_emit_tuple optionlist_emitter (uiout, "optionlist");
 677           const char *new_prefix = strstr (list->prefixname, "show ") + 5;
 678
 679           if (uiout->is_mi_like_p ())
 680             uiout->field_string ("prefix", new_prefix);
 681           cmd_show_list (*list->prefixlist, from_tty, new_prefix);
 682         }
 683       else
 684         {
 685           if (list->theclass != no_set_class)
 686             {
 687               ui_out_emit_tuple option_emitter (uiout, "option");
 688
 689               uiout->text (prefix);
 690               uiout->field_string ("name", list->name);
 691               uiout->text (":  ");
 692               if (list->type == show_cmd)
 693                 do_show_command ((char *) NULL, from_tty, list);
 694               else
 695                 cmd_func (list, NULL, from_tty);
 696             }
 697         }
 698     }
 699 }
 700