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           *(char **) c->var = tilde_expand (arg);
 196           break;
 197         case var_boolean:
 198           *(int *) c->var = parse_binary_operation (arg);
 199           break;
 200         case var_auto_boolean:
 201           *(enum auto_boolean *) c->var = parse_auto_binary_operation (arg);
 202           break;
 203         case var_uinteger:
 204           if (arg == NULL)
 205             error_no_arg (_("integer to set it to."));
 206           *(unsigned int *) c->var = parse_and_eval_long (arg);
 207           if (*(unsigned int *) c->var == 0)
 208             *(unsigned int *) c->var = UINT_MAX;
 209           break;
 210         case var_integer:
 211           {
 212             unsigned int val;
 213             if (arg == NULL)
 214               error_no_arg (_("integer to set it to."));
 215             val = parse_and_eval_long (arg);
 216             if (val == 0)
 217               *(int *) c->var = INT_MAX;
 218             else if (val >= INT_MAX)
 219               error (_("integer %u out of range"), val);
 220             else
 221               *(int *) c->var = val;
 222             break;
 223           }
 224         case var_zinteger:
 225           if (arg == NULL)
 226             error_no_arg (_("integer to set it to."));
 227           *(int *) c->var = parse_and_eval_long (arg);
 228           break;
 229         case var_enum:
 230           {
 231             int i;
 232             int len;
 233             int nmatches;
 234             const char *match = NULL;
 235             char *p;
 236
 237             /* if no argument was supplied, print an informative error message */
 238             if (arg == NULL)
 239               {
 240                 char msg[1024];
 241                 strcpy (msg, "Requires an argument. Valid arguments are ");
 242                 for (i = 0; c->enums[i]; i++)
 243                   {
 244                     if (i != 0)
 245                       strcat (msg, ", ");
 246                     strcat (msg, c->enums[i]);
 247                   }
 248                 strcat (msg, ".");
 249                 error (("%s"), msg);
 250               }
 251
 252             p = strchr (arg, ' ');
 253
 254             if (p)
 255               len = p - arg;
 256             else
 257               len = strlen (arg);
 258
 259             nmatches = 0;
 260             for (i = 0; c->enums[i]; i++)
 261               if (strncmp (arg, c->enums[i], len) == 0)
 262                 {
 263                   if (c->enums[i][len] == '\0')
 264                     {
 265                       match = c->enums[i];
 266                       nmatches = 1;
 267                       break; /* exact match. */
 268                     }
 269                   else
 270                     {
 271                       match = c->enums[i];
 272                       nmatches++;
 273                     }
 274                 }
 275
 276             if (nmatches <= 0)
 277               error (_("Undefined item: \"%s\"."), arg);
 278
 279             if (nmatches > 1)
 280               error (_("Ambiguous item \"%s\"."), arg);
 281
 282             *(const char **) c->var = match;
 283           }
 284           break;
 285         default:
 286           error (_("gdb internal error: bad var_type in do_setshow_command"));
 287         }
 288     }
 289   else if (c->type == show_cmd)
 290     {
 291       struct cleanup *old_chain;
 292       struct ui_stream *stb;
 293
 294       stb = ui_out_stream_new (uiout);
 295       old_chain = make_cleanup_ui_out_stream_delete (stb);
 296
 297       /* Possibly call the pre hook.  */
 298       if (c->pre_show_hook)
 299         (c->pre_show_hook) (c);
 300
 301       switch (c->var_type)
 302         {
 303         case var_string:
 304           if (*(char **) c->var)
 305             fputstr_filtered (*(char **) c->var, '"', stb->stream);
 306           break;
 307         case var_string_noescape:
 308         case var_optional_filename:
 309         case var_filename:
 310         case var_enum:
 311           if (*(char **) c->var)
 312             fputs_filtered (*(char **) c->var, stb->stream);
 313           break;
 314         case var_boolean:
 315           fputs_filtered (*(int *) c->var ? "on" : "off", stb->stream);
 316           break;
 317         case var_auto_boolean:
 318           switch (*(enum auto_boolean*) c->var)
 319             {
 320             case AUTO_BOOLEAN_TRUE:
 321               fputs_filtered ("on", stb->stream);
 322               break;
 323             case AUTO_BOOLEAN_FALSE:
 324               fputs_filtered ("off", stb->stream);
 325               break;
 326             case AUTO_BOOLEAN_AUTO:
 327               fputs_filtered ("auto", stb->stream);
 328               break;
 329             default:
 330               internal_error (__FILE__, __LINE__,
 331                               _("do_setshow_command: invalid var_auto_boolean"));
 332               break;
 333             }
 334           break;
 335         case var_uinteger:
 336           if (*(unsigned int *) c->var == UINT_MAX)
 337             {
 338               fputs_filtered ("unlimited", stb->stream);
 339               break;
 340             }
 341           /* else fall through */
 342         case var_zinteger:
 343           fprintf_filtered (stb->stream, "%u", *(unsigned int *) c->var);
 344           break;
 345         case var_integer:
 346           if (*(int *) c->var == INT_MAX)
 347             {
 348               fputs_filtered ("unlimited", stb->stream);
 349             }
 350           else
 351             fprintf_filtered (stb->stream, "%d", *(int *) c->var);
 352           break;
 353
 354         default:
 355           error (_("gdb internal error: bad var_type in do_setshow_command"));
 356         }
 357
 358
 359       /* FIXME: cagney/2005-02-10: Need to split this in half: code to
 360          convert the value into a string (esentially the above); and
 361          code to print the value out.  For the latter there should be
 362          MI and CLI specific versions.  */
 363
 364       if (ui_out_is_mi_like_p (uiout))
 365         ui_out_field_stream (uiout, "value", stb);
 366       else
 367         {
 368           long length;
 369           char *value = ui_file_xstrdup (stb->stream, &length);
 370           make_cleanup (xfree, value);
 371           if (c->show_value_func != NULL)
 372             c->show_value_func (gdb_stdout, from_tty, c, value);
 373           else
 374             deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
 375         }
 376       do_cleanups (old_chain);
 377     }
 378   else
 379     error (_("gdb internal error: bad cmd_type in do_setshow_command"));
 380   c->func (c, NULL, from_tty);
 381   if (c->type == set_cmd && deprecated_set_hook)
 382     deprecated_set_hook (c);
 383 }
 384
 385 /* Show all the settings in a list of show commands.  */
 386
 387 void
 388 cmd_show_list (struct cmd_list_element *list, int from_tty, char *prefix)
 389 {
 390   struct cleanup *showlist_chain;
 391
 392   showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
 393   for (; list != NULL; list = list->next)
 394     {
 395       /* If we find a prefix, run its list, prefixing our output by its
 396          prefix (with "show " skipped).  */
 397       if (list->prefixlist && !list->abbrev_flag)
 398         {
 399           struct cleanup *optionlist_chain
 400             = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
 401           char *new_prefix = strstr (list->prefixname, "show ") + 5;
 402           if (ui_out_is_mi_like_p (uiout))
 403             ui_out_field_string (uiout, "prefix", new_prefix);
 404           cmd_show_list (*list->prefixlist, from_tty, new_prefix);
 405           /* Close the tuple.  */
 406           do_cleanups (optionlist_chain);
 407         }
 408       else
 409         {
 410           struct cleanup *option_chain
 411             = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
 412           ui_out_text (uiout, prefix);
 413           ui_out_field_string (uiout, "name", list->name);
 414           ui_out_text (uiout, ":  ");
 415           if (list->type == show_cmd)
 416             do_setshow_command ((char *) NULL, from_tty, list);
 417           else
 418             cmd_func (list, NULL, from_tty);
 419           /* Close the tuple.  */
 420           do_cleanups (option_chain);
 421         }
 422     }
 423   /* Close the tuple.  */
 424   do_cleanups (showlist_chain);
 425 }
 426