Commit | Line | Data |
---|---|---|
d318976c | 1 | /* Handle set and show GDB commands. |
8e65ff28 | 2 | Copyright 2000, 2001 Free Software Foundation, Inc. |
d318976c FN |
3 | |
4 | This program is free software; you can redistribute it and/or modify | |
5 | it under the terms of the GNU General Public License as published by | |
6 | the Free Software Foundation; either version 2 of the License, or | |
7 | (at your option) any later version. | |
8 | ||
9 | This program is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | GNU General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU General Public License | |
15 | along with this program; if not, write to the Free Software | |
16 | Foundation, Inc., 59 Temple Place - Suite 330, | |
17 | Boston, MA 02111-1307, USA. */ | |
18 | ||
19 | #include "defs.h" | |
20 | #include "value.h" | |
21 | #include <ctype.h> | |
22 | #if 0 | |
23 | #include "gdb_string.h" | |
24 | #endif | |
25 | ||
26 | #ifdef UI_OUT | |
27 | #include "ui-out.h" | |
28 | #endif | |
29 | ||
30 | #include "cli/cli-decode.h" | |
31 | #include "cli/cli-cmds.h" | |
32 | #include "cli/cli-setshow.h" | |
33 | ||
34 | /* Prototypes for local functions */ | |
35 | ||
36 | static int parse_binary_operation (char *); | |
37 | ||
38 | static enum cmd_auto_boolean parse_auto_binary_operation (const char *arg); | |
39 | \f | |
40 | static enum cmd_auto_boolean | |
41 | parse_auto_binary_operation (const char *arg) | |
42 | { | |
43 | if (arg != NULL && *arg != '\0') | |
44 | { | |
45 | int length = strlen (arg); | |
46 | while (isspace (arg[length - 1]) && length > 0) | |
47 | length--; | |
48 | if (strncmp (arg, "on", length) == 0 | |
49 | || strncmp (arg, "1", length) == 0 | |
50 | || strncmp (arg, "yes", length) == 0 | |
51 | || strncmp (arg, "enable", length) == 0) | |
52 | return CMD_AUTO_BOOLEAN_TRUE; | |
53 | else if (strncmp (arg, "off", length) == 0 | |
54 | || strncmp (arg, "0", length) == 0 | |
55 | || strncmp (arg, "no", length) == 0 | |
56 | || strncmp (arg, "disable", length) == 0) | |
57 | return CMD_AUTO_BOOLEAN_FALSE; | |
58 | else if (strncmp (arg, "auto", length) == 0 | |
59 | || (strncmp (arg, "-1", length) == 0 && length > 1)) | |
60 | return CMD_AUTO_BOOLEAN_AUTO; | |
61 | } | |
62 | error ("\"on\", \"off\" or \"auto\" expected."); | |
63 | return CMD_AUTO_BOOLEAN_AUTO; /* pacify GCC */ | |
64 | } | |
65 | ||
66 | static int | |
67 | parse_binary_operation (char *arg) | |
68 | { | |
69 | int length; | |
70 | ||
71 | if (!arg || !*arg) | |
72 | return 1; | |
73 | ||
74 | length = strlen (arg); | |
75 | ||
76 | while (arg[length - 1] == ' ' || arg[length - 1] == '\t') | |
77 | length--; | |
78 | ||
79 | if (strncmp (arg, "on", length) == 0 | |
80 | || strncmp (arg, "1", length) == 0 | |
81 | || strncmp (arg, "yes", length) == 0 | |
82 | || strncmp (arg, "enable", length) == 0) | |
83 | return 1; | |
84 | else if (strncmp (arg, "off", length) == 0 | |
85 | || strncmp (arg, "0", length) == 0 | |
86 | || strncmp (arg, "no", length) == 0 | |
87 | || strncmp (arg, "disable", length) == 0) | |
88 | return 0; | |
89 | else | |
90 | { | |
91 | error ("\"on\" or \"off\" expected."); | |
92 | return 0; | |
93 | } | |
94 | } | |
95 | \f | |
96 | /* Do a "set" or "show" command. ARG is NULL if no argument, or the text | |
97 | of the argument, and FROM_TTY is nonzero if this command is being entered | |
98 | directly by the user (i.e. these are just like any other | |
99 | command). C is the command list element for the command. */ | |
100 | ||
101 | void | |
102 | do_setshow_command (char *arg, int from_tty, struct cmd_list_element *c) | |
103 | { | |
104 | if (c->type == set_cmd) | |
105 | { | |
106 | switch (c->var_type) | |
107 | { | |
108 | case var_string: | |
109 | { | |
110 | char *new; | |
111 | char *p; | |
112 | char *q; | |
113 | int ch; | |
114 | ||
115 | if (arg == NULL) | |
116 | arg = ""; | |
117 | new = (char *) xmalloc (strlen (arg) + 2); | |
118 | p = arg; | |
119 | q = new; | |
120 | while ((ch = *p++) != '\000') | |
121 | { | |
122 | if (ch == '\\') | |
123 | { | |
124 | /* \ at end of argument is used after spaces | |
125 | so they won't be lost. */ | |
126 | /* This is obsolete now that we no longer strip | |
127 | trailing whitespace and actually, the backslash | |
128 | didn't get here in my test, readline or | |
129 | something did something funky with a backslash | |
130 | right before a newline. */ | |
131 | if (*p == 0) | |
132 | break; | |
133 | ch = parse_escape (&p); | |
134 | if (ch == 0) | |
135 | break; /* C loses */ | |
136 | else if (ch > 0) | |
137 | *q++ = ch; | |
138 | } | |
139 | else | |
140 | *q++ = ch; | |
141 | } | |
142 | #if 0 | |
143 | if (*(p - 1) != '\\') | |
144 | *q++ = ' '; | |
145 | #endif | |
146 | *q++ = '\0'; | |
147 | new = (char *) xrealloc (new, q - new); | |
148 | if (*(char **) c->var != NULL) | |
b8c9b27d | 149 | xfree (*(char **) c->var); |
d318976c FN |
150 | *(char **) c->var = new; |
151 | } | |
152 | break; | |
153 | case var_string_noescape: | |
154 | if (arg == NULL) | |
155 | arg = ""; | |
156 | if (*(char **) c->var != NULL) | |
b8c9b27d | 157 | xfree (*(char **) c->var); |
d318976c FN |
158 | *(char **) c->var = savestring (arg, strlen (arg)); |
159 | break; | |
160 | case var_filename: | |
161 | if (arg == NULL) | |
162 | error_no_arg ("filename to set it to."); | |
163 | if (*(char **) c->var != NULL) | |
b8c9b27d | 164 | xfree (*(char **) c->var); |
d318976c FN |
165 | *(char **) c->var = tilde_expand (arg); |
166 | break; | |
167 | case var_boolean: | |
168 | *(int *) c->var = parse_binary_operation (arg); | |
169 | break; | |
170 | case var_auto_boolean: | |
171 | *(enum cmd_auto_boolean *) c->var = parse_auto_binary_operation (arg); | |
172 | break; | |
173 | case var_uinteger: | |
174 | if (arg == NULL) | |
175 | error_no_arg ("integer to set it to."); | |
176 | *(unsigned int *) c->var = parse_and_eval_long (arg); | |
177 | if (*(unsigned int *) c->var == 0) | |
178 | *(unsigned int *) c->var = UINT_MAX; | |
179 | break; | |
180 | case var_integer: | |
181 | { | |
182 | unsigned int val; | |
183 | if (arg == NULL) | |
184 | error_no_arg ("integer to set it to."); | |
185 | val = parse_and_eval_long (arg); | |
186 | if (val == 0) | |
187 | *(int *) c->var = INT_MAX; | |
188 | else if (val >= INT_MAX) | |
189 | error ("integer %u out of range", val); | |
190 | else | |
191 | *(int *) c->var = val; | |
192 | break; | |
193 | } | |
194 | case var_zinteger: | |
195 | if (arg == NULL) | |
196 | error_no_arg ("integer to set it to."); | |
197 | *(int *) c->var = parse_and_eval_long (arg); | |
198 | break; | |
199 | case var_enum: | |
200 | { | |
201 | int i; | |
202 | int len; | |
203 | int nmatches; | |
204 | const char *match = NULL; | |
205 | char *p; | |
206 | ||
207 | /* if no argument was supplied, print an informative error message */ | |
208 | if (arg == NULL) | |
209 | { | |
210 | char msg[1024]; | |
211 | strcpy (msg, "Requires an argument. Valid arguments are "); | |
212 | for (i = 0; c->enums[i]; i++) | |
213 | { | |
214 | if (i != 0) | |
215 | strcat (msg, ", "); | |
216 | strcat (msg, c->enums[i]); | |
217 | } | |
218 | strcat (msg, "."); | |
219 | error (msg); | |
220 | } | |
221 | ||
222 | p = strchr (arg, ' '); | |
223 | ||
224 | if (p) | |
225 | len = p - arg; | |
226 | else | |
227 | len = strlen (arg); | |
228 | ||
229 | nmatches = 0; | |
230 | for (i = 0; c->enums[i]; i++) | |
231 | if (strncmp (arg, c->enums[i], len) == 0) | |
232 | { | |
233 | if (c->enums[i][len] == '\0') | |
234 | { | |
235 | match = c->enums[i]; | |
236 | nmatches = 1; | |
237 | break; /* exact match. */ | |
238 | } | |
239 | else | |
240 | { | |
241 | match = c->enums[i]; | |
242 | nmatches++; | |
243 | } | |
244 | } | |
245 | ||
246 | if (nmatches <= 0) | |
247 | error ("Undefined item: \"%s\".", arg); | |
248 | ||
249 | if (nmatches > 1) | |
250 | error ("Ambiguous item \"%s\".", arg); | |
251 | ||
252 | *(const char **) c->var = match; | |
253 | } | |
254 | break; | |
255 | default: | |
256 | error ("gdb internal error: bad var_type in do_setshow_command"); | |
257 | } | |
258 | } | |
259 | else if (c->type == show_cmd) | |
260 | { | |
261 | #ifdef UI_OUT | |
262 | struct cleanup *old_chain; | |
263 | struct ui_stream *stb; | |
264 | int quote; | |
265 | ||
266 | stb = ui_out_stream_new (uiout); | |
267 | old_chain = make_cleanup_ui_out_stream_delete (stb); | |
268 | #endif /* UI_OUT */ | |
269 | ||
270 | /* Print doc minus "show" at start. */ | |
271 | print_doc_line (gdb_stdout, c->doc + 5); | |
272 | ||
273 | #ifdef UI_OUT | |
274 | ui_out_text (uiout, " is "); | |
275 | ui_out_wrap_hint (uiout, " "); | |
276 | quote = 0; | |
277 | switch (c->var_type) | |
278 | { | |
279 | case var_string: | |
280 | { | |
281 | unsigned char *p; | |
282 | ||
283 | if (*(unsigned char **) c->var) | |
284 | fputstr_filtered (*(unsigned char **) c->var, '"', stb->stream); | |
285 | quote = 1; | |
286 | } | |
287 | break; | |
288 | case var_string_noescape: | |
289 | case var_filename: | |
290 | case var_enum: | |
291 | if (*(char **) c->var) | |
292 | fputs_filtered (*(char **) c->var, stb->stream); | |
293 | quote = 1; | |
294 | break; | |
295 | case var_boolean: | |
296 | fputs_filtered (*(int *) c->var ? "on" : "off", stb->stream); | |
297 | break; | |
298 | case var_auto_boolean: | |
299 | switch (*(enum cmd_auto_boolean*) c->var) | |
300 | { | |
301 | case CMD_AUTO_BOOLEAN_TRUE: | |
302 | fputs_filtered ("on", stb->stream); | |
303 | break; | |
304 | case CMD_AUTO_BOOLEAN_FALSE: | |
305 | fputs_filtered ("off", stb->stream); | |
306 | break; | |
307 | case CMD_AUTO_BOOLEAN_AUTO: | |
308 | fputs_filtered ("auto", stb->stream); | |
309 | break; | |
310 | default: | |
8e65ff28 AC |
311 | internal_error (__FILE__, __LINE__, |
312 | "do_setshow_command: invalid var_auto_boolean"); | |
d318976c FN |
313 | break; |
314 | } | |
315 | break; | |
316 | case var_uinteger: | |
317 | if (*(unsigned int *) c->var == UINT_MAX) | |
318 | { | |
319 | fputs_filtered ("unlimited", stb->stream); | |
320 | break; | |
321 | } | |
322 | /* else fall through */ | |
323 | case var_zinteger: | |
324 | fprintf_filtered (stb->stream, "%u", *(unsigned int *) c->var); | |
325 | break; | |
326 | case var_integer: | |
327 | if (*(int *) c->var == INT_MAX) | |
328 | { | |
329 | fputs_filtered ("unlimited", stb->stream); | |
330 | } | |
331 | else | |
332 | fprintf_filtered (stb->stream, "%d", *(int *) c->var); | |
333 | break; | |
334 | ||
335 | default: | |
336 | error ("gdb internal error: bad var_type in do_setshow_command"); | |
337 | } | |
338 | if (quote) | |
339 | ui_out_text (uiout, "\""); | |
340 | ui_out_field_stream (uiout, "value", stb); | |
341 | if (quote) | |
342 | ui_out_text (uiout, "\""); | |
343 | ui_out_text (uiout, ".\n"); | |
344 | do_cleanups (old_chain); | |
345 | #else | |
346 | fputs_filtered (" is ", gdb_stdout); | |
347 | wrap_here (" "); | |
348 | switch (c->var_type) | |
349 | { | |
350 | case var_string: | |
351 | { | |
352 | fputs_filtered ("\"", gdb_stdout); | |
353 | if (*(unsigned char **) c->var) | |
354 | fputstr_filtered (*(unsigned char **) c->var, '"', gdb_stdout); | |
355 | fputs_filtered ("\"", gdb_stdout); | |
356 | } | |
357 | break; | |
358 | case var_string_noescape: | |
359 | case var_filename: | |
360 | case var_enum: | |
361 | fputs_filtered ("\"", gdb_stdout); | |
362 | if (*(char **) c->var) | |
363 | fputs_filtered (*(char **) c->var, gdb_stdout); | |
364 | fputs_filtered ("\"", gdb_stdout); | |
365 | break; | |
366 | case var_boolean: | |
367 | fputs_filtered (*(int *) c->var ? "on" : "off", gdb_stdout); | |
368 | break; | |
369 | case var_auto_boolean: | |
370 | switch (*(enum cmd_auto_boolean*) c->var) | |
371 | { | |
372 | case CMD_AUTO_BOOLEAN_TRUE: | |
373 | fputs_filtered ("on", gdb_stdout); | |
374 | break; | |
375 | case CMD_AUTO_BOOLEAN_FALSE: | |
376 | fputs_filtered ("off", gdb_stdout); | |
377 | break; | |
378 | case CMD_AUTO_BOOLEAN_AUTO: | |
379 | fputs_filtered ("auto", gdb_stdout); | |
380 | break; | |
381 | default: | |
8e65ff28 AC |
382 | internal_error (__FILE__, __LINE__, |
383 | "do_setshow_command: invalid var_auto_boolean"); | |
d318976c FN |
384 | break; |
385 | } | |
386 | break; | |
387 | case var_uinteger: | |
388 | if (*(unsigned int *) c->var == UINT_MAX) | |
389 | { | |
390 | fputs_filtered ("unlimited", gdb_stdout); | |
391 | break; | |
392 | } | |
393 | /* else fall through */ | |
394 | case var_zinteger: | |
395 | fprintf_filtered (gdb_stdout, "%u", *(unsigned int *) c->var); | |
396 | break; | |
397 | case var_integer: | |
398 | if (*(int *) c->var == INT_MAX) | |
399 | { | |
400 | fputs_filtered ("unlimited", gdb_stdout); | |
401 | } | |
402 | else | |
403 | fprintf_filtered (gdb_stdout, "%d", *(int *) c->var); | |
404 | break; | |
405 | ||
406 | default: | |
407 | error ("gdb internal error: bad var_type in do_setshow_command"); | |
408 | } | |
409 | fputs_filtered (".\n", gdb_stdout); | |
410 | #endif | |
411 | } | |
412 | else | |
413 | error ("gdb internal error: bad cmd_type in do_setshow_command"); | |
414 | (*c->function.sfunc) (NULL, from_tty, c); | |
415 | if (c->type == set_cmd && set_hook) | |
416 | set_hook (c); | |
417 | } | |
418 | ||
419 | /* Show all the settings in a list of show commands. */ | |
420 | ||
421 | void | |
422 | cmd_show_list (struct cmd_list_element *list, int from_tty, char *prefix) | |
423 | { | |
424 | #ifdef UI_OUT | |
666547aa | 425 | ui_out_tuple_begin (uiout, "showlist"); |
d318976c FN |
426 | #endif |
427 | for (; list != NULL; list = list->next) | |
428 | { | |
429 | /* If we find a prefix, run its list, prefixing our output by its | |
430 | prefix (with "show " skipped). */ | |
431 | #ifdef UI_OUT | |
432 | if (list->prefixlist && !list->abbrev_flag) | |
433 | { | |
666547aa | 434 | ui_out_tuple_begin (uiout, "optionlist"); |
d318976c FN |
435 | ui_out_field_string (uiout, "prefix", list->prefixname + 5); |
436 | cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5); | |
666547aa | 437 | ui_out_tuple_end (uiout); |
d318976c FN |
438 | } |
439 | if (list->type == show_cmd) | |
440 | { | |
666547aa | 441 | ui_out_tuple_begin (uiout, "option"); |
d318976c FN |
442 | ui_out_text (uiout, prefix); |
443 | ui_out_field_string (uiout, "name", list->name); | |
444 | ui_out_text (uiout, ": "); | |
445 | do_setshow_command ((char *) NULL, from_tty, list); | |
666547aa | 446 | ui_out_tuple_end (uiout); |
d318976c FN |
447 | } |
448 | #else | |
449 | if (list->prefixlist && !list->abbrev_flag) | |
450 | cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5); | |
451 | if (list->type == show_cmd) | |
452 | { | |
453 | fputs_filtered (prefix, gdb_stdout); | |
454 | fputs_filtered (list->name, gdb_stdout); | |
455 | fputs_filtered (": ", gdb_stdout); | |
456 | do_setshow_command ((char *) NULL, from_tty, list); | |
457 | } | |
458 | #endif | |
459 | } | |
460 | #ifdef UI_OUT | |
666547aa | 461 | ui_out_tuple_end (uiout); |
d318976c FN |
462 | #endif |
463 | } | |
464 |