GDB (xrefs)
cli-setshow.c
Go to the documentation of this file.
1 /* Handle set and show GDB commands.
2 
3  Copyright (C) 2000-2015 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 
41  || c->theclass == class_obscure)
42  return 0;
43 
44  return 1;
45 }
46 
47 
48 static enum auto_boolean
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
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 
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:
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
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 */
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  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 = 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;
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 = xmalloc (length);
479  cmds = xmalloc (sizeof (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:
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";
527 
529  }
530  break;
531  case var_auto_boolean:
532  {
533  const char *s = auto_boolean_enums[*(enum auto_boolean *) c->var];
534 
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);
545  }
546  break;
547  case var_integer:
548  case var_zinteger:
550  {
551  char s[64];
552 
553  xsnprintf (s, sizeof s, "%d", *(int *) c->var);
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  struct cleanup *old_chain;
572  struct ui_file *stb;
573 
574  gdb_assert (c->type == show_cmd);
575 
576  stb = mem_fileopen ();
577  old_chain = make_cleanup_ui_file_delete (stb);
578 
579  /* Possibly call the pre hook. */
580  if (c->pre_show_hook)
581  (c->pre_show_hook) (c);
582 
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:
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;
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  }
645 
646 
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. */
651 
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);
657 
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);
665 
666  c->func (c, NULL, from_tty);
667 }
668 
669 /* Show all the settings in a list of show commands. */
670 
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;
676 
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;
687 
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->theclass != no_set_class)
697  {
698  struct cleanup *option_chain
699  = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
700 
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 }
716 
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
const char * name
Definition: cli-decode.h:53
struct cmd_list_element * next
Definition: cli-decode.h:50
int parse_cli_boolean_value(const char *arg)
Definition: cli-setshow.c:78
void ui_out_field_stream(struct ui_out *uiout, const char *fldname, struct ui_file *stream)
Definition: ui-out.c:509
void xfree(void *)
Definition: common-utils.c:97
static enum auto_boolean parse_auto_binary_operation(const char *arg)
Definition: cli-setshow.c:49
__extension__ enum cmd_types type
Definition: cli-decode.h:101
#define INT_MAX
Definition: defs.h:509
void print_doc_line(struct ui_file *stream, const char *str)
Definition: cli-decode.c:1122
const char *const * enums
Definition: cli-decode.h:199
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
#define INT_MIN
Definition: defs.h:513
struct ui_file * gdb_stdout
Definition: main.c:71
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
#define _(String)
Definition: gdb_locale.h:40
struct cmd_list_element * prefix
Definition: cli-decode.h:162
Definition: ui-out.c:99
void ui_out_text(struct ui_out *uiout, const char *string)
Definition: ui-out.c:582
void printf_filtered(const char *format,...)
Definition: utils.c:2388
void cmd_func(struct cmd_list_element *cmd, char *args, int from_tty)
Definition: cli-decode.c:1883
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
#define UINT_MAX
Definition: defs.h:505
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
__extension__ enum var_types var_type
Definition: cli-decode.h:104
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
#define gdb_assert(expr)
Definition: gdb_assert.h:33
unsigned int abbrev_flag
Definition: cli-decode.h:97
void * xmalloc(YYSIZE_T)
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:672
void(* pre_show_hook)(struct cmd_list_element *c)
Definition: cli-decode.h:142
int parse_escape(struct gdbarch *gdbarch, const char **string_ptr)
Definition: utils.c:1421
Definition: value.c:172
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
void deprecated_show_value_hack(struct ui_file *ignore_file, int ignore_from_tty, struct cmd_list_element *c, const char *value)
Definition: cli-setshow.c:105
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
void(* func)(struct cmd_list_element *c, char *args, int from_tty)
Definition: cli-decode.h:111
enum command_class theclass
Definition: cli-decode.h:56
void observer_notify_command_param_changed(const char *param, const char *value)
auto_boolean
Definition: defs.h:196
static int notify_command_param_changed_p(int param_changed, struct cmd_list_element *c)
Definition: cli-setshow.c:35
show_value_ftype * show_value_func
Definition: cli-decode.h:135
void do_set_command(const char *arg, int from_tty, struct cmd_list_element *c)
Definition: cli-setshow.c:150
const char * doc
Definition: cli-decode.h:131
struct cmd_list_element ** prefixlist
Definition: cli-decode.h:152
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
void do_show_command(const char *arg, int from_tty, struct cmd_list_element *c)
Definition: cli-setshow.c:568
void * arg
Definition: cleanups.c:43
struct ui_out * current_uiout
Definition: ui-out.c:233
const char * prefixname
Definition: cli-decode.h:159
const char *const auto_boolean_enums[]
Definition: cli-decode.c:509
void error(const char *fmt,...)
Definition: errors.c:38
void fputstr_filtered(const char *str, int quoter, struct ui_file *stream)
Definition: utils.c:1559
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static int is_unlimited_literal(const char *arg)
Definition: cli-setshow.c:133
const ULONGEST const LONGEST len
Definition: target.h:309
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111