gdb/cli/cli-setshow.c

   1 /* Handle set and show GDB commands.
   2
   3    Copyright (c) 2000, 2001, 2002, 2003, 2007 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 2 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, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.  */
  19
  20 #include "defs.h"
  21 #include "readline/tilde.h"
  22 #include "value.h"
  23 #include <ctype.h>
  24 #include "gdb_string.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
  32 /* Prototypes for local functions */
  33
  34 static int parse_binary_operation (char *);
  35
  36 \f
  37 static enum auto_boolean
  38 parse_auto_binary_operation (const char *arg)
  39 {
  40   if (arg != NULL && *arg != '\0')
  41     {
  42       int length = strlen (arg);
  43       while (isspace (arg[length - 1]) && length > 0)
  44         length--;
  45       if (strncmp (arg, "on", length) == 0
  46           || strncmp (arg, "1", length) == 0
  47           || strncmp (arg, "yes", length) == 0
  48           || strncmp (arg, "enable", length) == 0)
  49         return AUTO_BOOLEAN_TRUE;
  50       else if (strncmp (arg, "off", length) == 0
  51                || strncmp (arg, "0", length) == 0
  52                || strncmp (arg, "no", length) == 0
  53                || strncmp (arg, "disable", length) == 0)
  54         return AUTO_BOOLEAN_FALSE;
  55       else if (strncmp (arg, "auto", length) == 0
  56                || (strncmp (arg, "-1", length) == 0 && length > 1))
  57         return AUTO_BOOLEAN_AUTO;
  58     }
  59   error (_("\"on\", \"off\" or \"auto\" expected."));
  60   return AUTO_BOOLEAN_AUTO; /* pacify GCC */
  61 }
  62
  63 static int
  64 parse_binary_operation (char *arg)
  65 {
  66   int length;
  67
  68   if (!arg || !*arg)
  69     return 1;
  70
  71   length = strlen (arg);
  72
  73   while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
  74     length--;
  75
  76   if (strncmp (arg, "on", length) == 0
  77       || strncmp (arg, "1", length) == 0
  78       || strncmp (arg, "yes", length) == 0
  79       || strncmp (arg, "enable", length) == 0)
  80     return 1;
  81   else if (strncmp (arg, "off", length) == 0
  82            || strncmp (arg, "0", length) == 0
  83            || strncmp (arg, "no", length) == 0
  84            || strncmp (arg, "disable", length) == 0)
  85     return 0;
  86   else
  87     {
  88       error (_("\"on\" or \"off\" expected."));
  89       return 0;
  90     }
  91 }
  92 \f
  93 void
  94 deprecated_show_value_hack (struct ui_file *ignore_file,
  95                             int ignore_from_tty,
  96                             struct cmd_list_element *c,
  97                             const char *value)
  98 {
  99   /* If there's no command or value, don't try to print it out.  */
 100   if (c == NULL || value == NULL)
 101     return;
 102   /* Print doc minus "show" at start.  */
 103   print_doc_line (gdb_stdout, c->doc + 5);
 104   switch (c->var_type)
 105     {
 106     case var_string:
 107     case var_string_noescape:
 108     case var_optional_filename:
 109     case var_filename:
 110     case var_enum:
 111       printf_filtered ((" is \"%s\".\n"), value);
 112       break;
 113     default:
 114       printf_filtered ((" is %s.\n"), value);
 115       break;
 116     }
 117 }
 118
 119 /* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
 120    of the argument, and FROM_TTY is nonzero if this command is being entered
 121    directly by the user (i.e. these are just like any other
 122    command).  C is the command list element for the command.  */
 123
 124 void
 125 do_setshow_command (char *arg, int from_tty, struct cmd_list_element *c)
 126 {
 127   if (c->type == set_cmd)
 128     {
 129       switch (c->var_type)
 130         {
 131         case var_string:
 132           {
 133             char *new;
 134             char *p;
 135             char *q;
 136             int ch;
 137
 138             if (arg == NULL)
 139               arg = "";
 140             new = (char *) xmalloc (strlen (arg) + 2);
 141             p = arg;
 142             q = new;
 143             while ((ch = *p++) != '\000')
 144               {
 145                 if (ch == '\\')
 146                   {
 147                     /* \ at end of argument is used after spaces
 148                        so they won't be lost.  */
 149                     /* This is obsolete now that we no longer strip
 150                        trailing whitespace and actually, the backslash
 151                        didn't get here in my test, readline or
 152                        something did something funky with a backslash
 153                        right before a newline.  */
 154                     if (*p == 0)
 155                       break;
 156                     ch = parse_escape (&p);
 157                     if (ch == 0)
 158                       break;    /* C loses */
 159                     else if (ch > 0)
 160                       *q++ = ch;
 161                   }
 162                 else
 163                   *q++ = ch;
 164               }
 165 #if 0
 166             if (*(p - 1) != '\\')
 167               *q++ = ' ';
 168 #endif
 169             *q++ = '\0';
 170             new = (char *) xrealloc (new, q - new);
 171             if (*(char **) c->var != NULL)
 172               xfree (*(char **) c->var);
 173             *(char **) c->var = new;
 174           }
 175           break;
 176         case var_string_noescape:
 177           if (arg == NULL)
 178             arg = "";
 179           if (*(char **) c->var != NULL)
 180             xfree (*(char **) c->var);
 181           *(char **) c->var = savestring (arg, strlen (arg));
 182           break;
 183         case var_optional_filename:
 184           if (arg == NULL)
 185             arg = "";
 186           if (*(char **) c->var != NULL)
 187             xfree (*(char **) c->var);
 188           *(char **) c->var = savestring (arg, strlen (arg));
 189           break;
 190         case var_filename:
 191           if (arg == NULL)
 192             error_no_arg (_("filename to set it to."));
 193           if (*(char **) c->var != NULL)
 194             xfree (*(char **) c->var);
 195           {
 196             /* Clear trailing whitespace of filename.  */
 197             char *ptr = arg + strlen (arg) - 1;
 198             while (ptr >= arg && (*ptr == ' ' || *ptr == '\t'))
 199               ptr--;
 200             *(ptr + 1) = '\0';
 201           }
 202           *(char **) c->var = tilde_expand (arg);
 203           break;
 204         case var_boolean:
 205           *(int *) c->var = parse_binary_operation (arg);
 206           break;
 207         case var_auto_boolean:
 208           *(enum auto_boolean *) c->var = parse_auto_binary_operation (arg);
 209           break;
 210         case var_uinteger:
 211           if (arg == NULL)
 212             error_no_arg (_("integer to set it to."));
 213           *(unsigned int *) c->var = parse_and_eval_long (arg);
 214           if (*(unsigned int *) c->var == 0)
 215             *(unsigned int *) c->var = UINT_MAX;
 216           break;
 217         case var_integer:
 218           {
 219             unsigned int val;
 220             if (arg == NULL)
 221               error_no_arg (_("integer to set it to."));
 222             val = parse_and_eval_long (arg);
 223             if (val == 0)
 224               *(int *) c->var = INT_MAX;
 225             else if (val >= INT_MAX)
 226               error (_("integer %u out of range"), val);
 227             else
 228               *(int *) c->var = val;
 229             break;
 230           }
 231         case var_zinteger:
 232           if (arg == NULL)
 233             error_no_arg (_("integer to set it to."));
 234           *(int *) c->var = parse_and_eval_long (arg);
 235           break;
 236         case var_enum:
 237           {
 238             int i;
 239             int len;
 240             int nmatches;
 241             const char *match = NULL;
 242             char *p;
 243
 244             /* if no argument was supplied, print an informative error message */
 245             if (arg == NULL)
 246               {
 247                 char msg[1024];
 248                 strcpy (msg, "Requires an argument. Valid arguments are ");
 249                 for (i = 0; c->enums[i]; i++)
 250                   {
 251                     if (i != 0)
 252                       strcat (msg, ", ");
 253                     strcat (msg, c->enums[i]);
 254                   }
 255                 strcat (msg, ".");
 256                 error (("%s"), msg);
 257               }
 258
 259             p = strchr (arg, ' ');
 260
 261             if (p)
 262               len = p - arg;
 263             else
 264               len = strlen (arg);
 265
 266             nmatches = 0;
 267             for (i = 0; c->enums[i]; i++)
 268               if (strncmp (arg, c->enums[i], len) == 0)
 269                 {
 270                   if (c->enums[i][len] == '\0')
 271                     {
 272                       match = c->enums[i];
 273                       nmatches = 1;
 274                       break; /* exact match. */
 275                     }
 276                   else
 277                     {
 278                       match = c->enums[i];
 279                       nmatches++;
 280                     }
 281                 }
 282
 283             if (nmatches <= 0)
 284               error (_("Undefined item: \"%s\"."), arg);
 285
 286             if (nmatches > 1)
 287               error (_("Ambiguous item \"%s\"."), arg);
 288
 289             *(const char **) c->var = match;
 290           }
 291           break;
 292         default:
 293           error (_("gdb internal error: bad var_type in do_setshow_command"));
 294         }
 295     }
 296   else if (c->type == show_cmd)
 297     {
 298       struct cleanup *old_chain;
 299       struct ui_stream *stb;
 300
 301       stb = ui_out_stream_new (uiout);
 302       old_chain = make_cleanup_ui_out_stream_delete (stb);
 303
 304       /* Possibly call the pre hook.  */
 305       if (c->pre_show_hook)
 306         (c->pre_show_hook) (c);
 307
 308       switch (c->var_type)
 309         {
 310         case var_string:
 311           if (*(char **) c->var)
 312             fputstr_filtered (*(char **) c->var, '"', stb->stream);
 313           break;
 314         case var_string_noescape:
 315         case var_optional_filename:
 316         case var_filename:
 317         case var_enum:
 318           if (*(char **) c->var)
 319             fputs_filtered (*(char **) c->var, stb->stream);
 320           break;
 321         case var_boolean:
 322           fputs_filtered (*(int *) c->var ? "on" : "off", stb->stream);
 323           break;
 324         case var_auto_boolean:
 325           switch (*(enum auto_boolean*) c->var)
 326             {
 327             case AUTO_BOOLEAN_TRUE:
 328               fputs_filtered ("on", stb->stream);
 329               break;
 330             case AUTO_BOOLEAN_FALSE:
 331               fputs_filtered ("off", stb->stream);
 332               break;
 333             case AUTO_BOOLEAN_AUTO:
 334               fputs_filtered ("auto", stb->stream);
 335               break;
 336             default:
 337               internal_error (__FILE__, __LINE__,
 338                               _("do_setshow_command: invalid var_auto_boolean"));
 339               break;
 340             }
 341           break;
 342         case var_uinteger:
 343           if (*(unsigned int *) c->var == UINT_MAX)
 344             {
 345               fputs_filtered ("unlimited", stb->stream);
 346               break;
 347             }
 348           /* else fall through */
 349         case var_zinteger:
 350           fprintf_filtered (stb->stream, "%u", *(unsigned int *) c->var);
 351           break;
 352         case var_integer:
 353           if (*(int *) c->var == INT_MAX)
 354             {
 355               fputs_filtered ("unlimited", stb->stream);
 356             }
 357           else
 358             fprintf_filtered (stb->stream, "%d", *(int *) c->var);
 359           break;
 360
 361         default:
 362           error (_("gdb internal error: bad var_type in do_setshow_command"));
 363         }
 364
 365
 366       /* FIXME: cagney/2005-02-10: Need to split this in half: code to
 367          convert the value into a string (esentially the above); and
 368          code to print the value out.  For the latter there should be
 369          MI and CLI specific versions.  */
 370
 371       if (ui_out_is_mi_like_p (uiout))
 372         ui_out_field_stream (uiout, "value", stb);
 373       else
 374         {
 375           long length;
 376           char *value = ui_file_xstrdup (stb->stream, &length);
 377           make_cleanup (xfree, value);
 378           if (c->show_value_func != NULL)
 379             c->show_value_func (gdb_stdout, from_tty, c, value);
 380           else
 381             deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
 382         }
 383       do_cleanups (old_chain);
 384     }
 385   else
 386     error (_("gdb internal error: bad cmd_type in do_setshow_command"));
 387   c->func (c, NULL, from_tty);
 388   if (c->type == set_cmd && deprecated_set_hook)
 389     deprecated_set_hook (c);
 390 }
 391
 392 /* Show all the settings in a list of show commands.  */
 393
 394 void
 395 cmd_show_list (struct cmd_list_element *list, int from_tty, char *prefix)
 396 {
 397   struct cleanup *showlist_chain;
 398
 399   showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
 400   for (; list != NULL; list = list->next)
 401     {
 402       /* If we find a prefix, run its list, prefixing our output by its
 403          prefix (with "show " skipped).  */
 404       if (list->prefixlist && !list->abbrev_flag)
 405         {
 406           struct cleanup *optionlist_chain
 407             = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
 408           char *new_prefix = strstr (list->prefixname, "show ") + 5;
 409           if (ui_out_is_mi_like_p (uiout))
 410             ui_out_field_string (uiout, "prefix", new_prefix);
 411           cmd_show_list (*list->prefixlist, from_tty, new_prefix);
 412           /* Close the tuple.  */
 413           do_cleanups (optionlist_chain);
 414         }
 415       else
 416         {
 417           struct cleanup *option_chain
 418             = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
 419           ui_out_text (uiout, prefix);
 420           ui_out_field_string (uiout, "name", list->name);
 421           ui_out_text (uiout, ":  ");
 422           if (list->type == show_cmd)
 423             do_setshow_command ((char *) NULL, from_tty, list);
 424           else
 425             cmd_func (list, NULL, from_tty);
 426           /* Close the tuple.  */
 427           do_cleanups (option_chain);
 428         }
 429     }
 430   /* Close the tuple.  */
 431   do_cleanups (showlist_chain);
 432 }
 433