GDB (xrefs)
scm-param.c
Go to the documentation of this file.
1 /* GDB parameters implemented in Guile.
2 
3  Copyright (C) 2008-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "value.h"
22 #include "charset.h"
23 #include "gdbcmd.h"
24 #include "cli/cli-decode.h"
25 #include "completer.h"
26 #include "language.h"
27 #include "arch-utils.h"
28 #include "guile-internal.h"
29 
30 /* A union that can hold anything described by enum var_types. */
31 
33 {
34  /* Hold an integer value, for boolean and integer types. */
35  int intval;
36 
37  /* Hold an auto_boolean. */
39 
40  /* Hold an unsigned integer value, for uinteger. */
41  unsigned int uintval;
42 
43  /* Hold a string, for the various string types. */
44  char *stringval;
45 
46  /* Hold a string, for enums. */
47  const char *cstringval;
48 };
49 
50 /* A GDB parameter.
51 
52  Note: Parameters are added to gdb using a two step process:
53  1) Call make-parameter to create a <gdb:parameter> object.
54  2) Call register-parameter! to add the parameter to gdb.
55  It is done this way so that the constructor, make-parameter, doesn't have
56  any side-effects. This means that the smob needs to store everything
57  that was passed to make-parameter.
58 
59  N.B. There is no free function for this smob.
60  All objects pointed to by this smob must live in GC space. */
61 
62 typedef struct _param_smob
63 {
64  /* This always appears first. */
66 
67  /* The parameter name. */
68  char *name;
69 
70  /* The last word of the command.
71  This is needed because add_cmd requires us to allocate space
72  for it. :-( */
73  char *cmd_name;
74 
75  /* One of the COMMAND_* constants. */
77 
78  /* The type of the parameter. */
80 
81  /* The docs for the parameter. */
82  char *set_doc;
83  char *show_doc;
84  char *doc;
85 
86  /* The corresponding gdb command objects.
87  These are NULL if the parameter has not been registered yet, or
88  is no longer registered. */
91 
92  /* The value of the parameter. */
94 
95  /* For an enum parameter, the possible values. The vector lives in GC
96  space, it will be freed with the smob. */
97  const char * const *enumeration;
98 
99  /* The set_func funcion or #f if not specified.
100  This function is called *after* the parameter is set.
101  It returns a string that will be displayed to the user. */
102  SCM set_func;
103 
104  /* The show_func function or #f if not specified.
105  This function returns the string that is printed. */
107 
108  /* The <gdb:parameter> object we are contained in, needed to
109  protect/unprotect the object since a reference to it comes from
110  non-gc-managed space (the command context pointer). */
112 } param_smob;
113 
114 static const char param_smob_name[] = "gdb:parameter";
115 
116 /* The tag Guile knows the param smob by. */
117 static scm_t_bits parameter_smob_tag;
118 
119 /* Keywords used by make-parameter!. */
122 static SCM enum_list_keyword;
123 static SCM set_func_keyword;
124 static SCM show_func_keyword;
125 static SCM doc_keyword;
126 static SCM set_doc_keyword;
127 static SCM show_doc_keyword;
129 static SCM auto_keyword;
130 static SCM unlimited_keyword;
131 
132 static int pascm_is_valid (param_smob *);
133 static const char *pascm_param_type_name (enum var_types type);
134 static SCM pascm_param_value (enum var_types type, void *var,
135  int arg_pos, const char *func_name);
136 
137 /* Administrivia for parameter smobs. */
138 
139 static int
140 pascm_print_param_smob (SCM self, SCM port, scm_print_state *pstate)
141 {
142  param_smob *p_smob = (param_smob *) SCM_SMOB_DATA (self);
143  SCM value;
144 
145  gdbscm_printf (port, "#<%s", param_smob_name);
146 
147  gdbscm_printf (port, " %s", p_smob->name);
148 
149  if (! pascm_is_valid (p_smob))
150  scm_puts (" {invalid}", port);
151 
152  gdbscm_printf (port, " %s ", pascm_param_type_name (p_smob->type));
153 
154  value = pascm_param_value (p_smob->type, &p_smob->value,
155  GDBSCM_ARG_NONE, NULL);
156  scm_display (value, port);
157 
158  scm_puts (">", port);
159 
160  scm_remember_upto_here_1 (self);
161 
162  /* Non-zero means success. */
163  return 1;
164 }
165 
166 /* Create an empty (uninitialized) parameter. */
167 
168 static SCM
170 {
171  param_smob *p_smob = (param_smob *)
172  scm_gc_malloc (sizeof (param_smob), param_smob_name);
173  SCM p_scm;
174 
175  memset (p_smob, 0, sizeof (*p_smob));
176  p_smob->cmd_class = no_class;
177  p_smob->type = var_boolean; /* ARI: var_boolean */
178  p_smob->set_func = SCM_BOOL_F;
179  p_smob->show_func = SCM_BOOL_F;
180  p_scm = scm_new_smob (parameter_smob_tag, (scm_t_bits) p_smob);
181  p_smob->containing_scm = p_scm;
182  gdbscm_init_gsmob (&p_smob->base);
183 
184  return p_scm;
185 }
186 
187 /* Returns non-zero if SCM is a <gdb:parameter> object. */
188 
189 static int
191 {
192  return SCM_SMOB_PREDICATE (parameter_smob_tag, scm);
193 }
194 
195 /* (gdb:parameter? scm) -> boolean */
196 
197 static SCM
199 {
200  return scm_from_bool (pascm_is_parameter (scm));
201 }
202 
203 /* Returns the <gdb:parameter> object in SELF.
204  Throws an exception if SELF is not a <gdb:parameter> object. */
205 
206 static SCM
207 pascm_get_param_arg_unsafe (SCM self, int arg_pos, const char *func_name)
208 {
209  SCM_ASSERT_TYPE (pascm_is_parameter (self), self, arg_pos, func_name,
211 
212  return self;
213 }
214 
215 /* Returns a pointer to the parameter smob of SELF.
216  Throws an exception if SELF is not a <gdb:parameter> object. */
217 
218 static param_smob *
219 pascm_get_param_smob_arg_unsafe (SCM self, int arg_pos, const char *func_name)
220 {
221  SCM p_scm = pascm_get_param_arg_unsafe (self, arg_pos, func_name);
222  param_smob *p_smob = (param_smob *) SCM_SMOB_DATA (p_scm);
223 
224  return p_smob;
225 }
226 
227 /* Return non-zero if parameter P_SMOB is valid. */
228 
229 static int
231 {
232  return p_smob->set_command != NULL;
233 }
234 
235 /* A helper function which return the default documentation string for
236  a parameter (which is to say that it's undocumented). */
237 
238 static char *
240 {
241  return xstrdup (_("This command is not documented."));
242 }
243 
244 /* Subroutine of pascm_set_func, pascm_show_func to simplify them.
245  Signal the error returned from calling set_func/show_func. */
246 
247 static void
248 pascm_signal_setshow_error (SCM exception, const char *msg)
249 {
250  /* Don't print the stack if this was an error signalled by the command
251  itself. */
252  if (gdbscm_user_error_p (gdbscm_exception_key (exception)))
253  {
254  char *excp_text = gdbscm_exception_message_to_string (exception);
255 
256  make_cleanup (xfree, excp_text);
257  error ("%s", excp_text);
258  }
259  else
260  {
261  gdbscm_print_gdb_exception (SCM_BOOL_F, exception);
262  error ("%s", msg);
263  }
264 }
265 
266 /* A callback function that is registered against the respective
267  add_setshow_* set_func prototype. This function will call
268  the Scheme function "set_func" which must exist.
269  Note: ARGS is always passed as NULL. */
270 
271 static void
272 pascm_set_func (char *args, int from_tty, struct cmd_list_element *c)
273 {
274  param_smob *p_smob = (param_smob *) get_cmd_context (c);
275  SCM self, result, exception;
276  char *msg;
277  struct cleanup *cleanups;
278 
280 
281  self = p_smob->containing_scm;
282 
283  result = gdbscm_safe_call_1 (p_smob->set_func, self, gdbscm_user_error_p);
284 
285  if (gdbscm_is_exception (result))
286  {
288  _("Error occurred setting parameter."));
289  }
290 
291  if (!scm_is_string (result))
292  error (_("Result of %s set-func is not a string."), p_smob->name);
293 
294  msg = gdbscm_scm_to_host_string (result, NULL, &exception);
295  if (msg == NULL)
296  {
297  gdbscm_print_gdb_exception (SCM_BOOL_F, exception);
298  error (_("Error converting show text to host string."));
299  }
300 
301  cleanups = make_cleanup (xfree, msg);
302  /* GDB is usually silent when a parameter is set. */
303  if (*msg != '\0')
304  fprintf_filtered (gdb_stdout, "%s\n", msg);
305  do_cleanups (cleanups);
306 }
307 
308 /* A callback function that is registered against the respective
309  add_setshow_* show_func prototype. This function will call
310  the Scheme function "show_func" which must exist and must return a
311  string that is then printed to FILE. */
312 
313 static void
314 pascm_show_func (struct ui_file *file, int from_tty,
315  struct cmd_list_element *c, const char *value)
316 {
317  param_smob *p_smob = (param_smob *) get_cmd_context (c);
318  SCM value_scm, self, result, exception;
319  char *msg;
320  struct cleanup *cleanups;
321 
323 
324  value_scm = gdbscm_scm_from_host_string (value, strlen (value));
325  if (gdbscm_is_exception (value_scm))
326  {
327  error (_("Error converting parameter value \"%s\" to Scheme string."),
328  value);
329  }
330  self = p_smob->containing_scm;
331 
332  result = gdbscm_safe_call_2 (p_smob->show_func, self, value_scm,
334 
335  if (gdbscm_is_exception (result))
336  {
338  _("Error occurred showing parameter."));
339  }
340 
341  msg = gdbscm_scm_to_host_string (result, NULL, &exception);
342  if (msg == NULL)
343  {
344  gdbscm_print_gdb_exception (SCM_BOOL_F, exception);
345  error (_("Error converting show text to host string."));
346  }
347 
348  cleanups = make_cleanup (xfree, msg);
349  fprintf_filtered (file, "%s\n", msg);
350  do_cleanups (cleanups);
351 }
352 
353 /* A helper function that dispatches to the appropriate add_setshow
354  function. */
355 
356 static void
357 add_setshow_generic (enum var_types param_type, enum command_class cmd_class,
358  char *cmd_name, param_smob *self,
359  char *set_doc, char *show_doc, char *help_doc,
360  cmd_sfunc_ftype *set_func,
361  show_value_ftype *show_func,
362  struct cmd_list_element **set_list,
363  struct cmd_list_element **show_list,
364  struct cmd_list_element **set_cmd,
365  struct cmd_list_element **show_cmd)
366 {
367  struct cmd_list_element *param = NULL;
368  const char *tmp_name = NULL;
369 
370  switch (param_type)
371  {
372  case var_boolean:
373  add_setshow_boolean_cmd (cmd_name, cmd_class,
374  &self->value.intval,
375  set_doc, show_doc, help_doc,
376  set_func, show_func,
377  set_list, show_list);
378 
379  break;
380 
381  case var_auto_boolean:
382  add_setshow_auto_boolean_cmd (cmd_name, cmd_class,
383  &self->value.autoboolval,
384  set_doc, show_doc, help_doc,
385  set_func, show_func,
386  set_list, show_list);
387  break;
388 
389  case var_uinteger:
390  add_setshow_uinteger_cmd (cmd_name, cmd_class,
391  &self->value.uintval,
392  set_doc, show_doc, help_doc,
393  set_func, show_func,
394  set_list, show_list);
395  break;
396 
397  case var_zinteger:
398  add_setshow_zinteger_cmd (cmd_name, cmd_class,
399  &self->value.intval,
400  set_doc, show_doc, help_doc,
401  set_func, show_func,
402  set_list, show_list);
403  break;
404 
405  case var_zuinteger:
406  add_setshow_zuinteger_cmd (cmd_name, cmd_class,
407  &self->value.uintval,
408  set_doc, show_doc, help_doc,
409  set_func, show_func,
410  set_list, show_list);
411  break;
412 
414  add_setshow_zuinteger_unlimited_cmd (cmd_name, cmd_class,
415  &self->value.intval,
416  set_doc, show_doc, help_doc,
417  set_func, show_func,
418  set_list, show_list);
419  break;
420 
421  case var_string:
422  add_setshow_string_cmd (cmd_name, cmd_class,
423  &self->value.stringval,
424  set_doc, show_doc, help_doc,
425  set_func, show_func,
426  set_list, show_list);
427  break;
428 
429  case var_string_noescape:
430  add_setshow_string_noescape_cmd (cmd_name, cmd_class,
431  &self->value.stringval,
432  set_doc, show_doc, help_doc,
433  set_func, show_func,
434  set_list, show_list);
435 
436  break;
437 
439  add_setshow_optional_filename_cmd (cmd_name, cmd_class,
440  &self->value.stringval,
441  set_doc, show_doc, help_doc,
442  set_func, show_func,
443  set_list, show_list);
444  break;
445 
446  case var_filename:
447  add_setshow_filename_cmd (cmd_name, cmd_class,
448  &self->value.stringval,
449  set_doc, show_doc, help_doc,
450  set_func, show_func,
451  set_list, show_list);
452  break;
453 
454  case var_enum:
455  add_setshow_enum_cmd (cmd_name, cmd_class,
456  self->enumeration,
457  &self->value.cstringval,
458  set_doc, show_doc, help_doc,
459  set_func, show_func,
460  set_list, show_list);
461  /* Initialize the value, just in case. */
462  self->value.cstringval = self->enumeration[0];
463  break;
464 
465  default:
466  gdb_assert_not_reached ("bad param_type value");
467  }
468 
469  /* Lookup created parameter, and register Scheme object against the
470  parameter context. Perform this task against both lists. */
471  tmp_name = cmd_name;
472  param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
473  gdb_assert (param != NULL);
474  set_cmd_context (param, self);
475  *set_cmd = param;
476 
477  tmp_name = cmd_name;
478  param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
479  gdb_assert (param != NULL);
480  set_cmd_context (param, self);
481  *show_cmd = param;
482 }
483 
484 /* Return an array of strings corresponding to the enum values for
485  ENUM_VALUES_SCM.
486  Throws an exception if there's a problem with the values.
487  Space for the result is allocated from the GC heap. */
488 
489 static const char * const *
490 compute_enum_list (SCM enum_values_scm, int arg_pos, const char *func_name)
491 {
492  long i, size;
493  char **enum_values;
494  const char * const *result;
495 
496  SCM_ASSERT_TYPE (gdbscm_is_true (scm_list_p (enum_values_scm)),
497  enum_values_scm, arg_pos, func_name, _("list"));
498 
499  size = scm_ilength (enum_values_scm);
500  if (size == 0)
501  {
502  gdbscm_out_of_range_error (FUNC_NAME, arg_pos, enum_values_scm,
503  _("enumeration list is empty"));
504  }
505 
506  enum_values = xmalloc ((size + 1) * sizeof (char *));
507  memset (enum_values, 0, (size + 1) * sizeof (char *));
508 
509  i = 0;
510  while (!scm_is_eq (enum_values_scm, SCM_EOL))
511  {
512  SCM value = scm_car (enum_values_scm);
513  SCM exception;
514 
515  if (!scm_is_string (value))
516  {
517  freeargv (enum_values);
518  SCM_ASSERT_TYPE (0, value, arg_pos, func_name, _("string"));
519  }
520  enum_values[i] = gdbscm_scm_to_host_string (value, NULL, &exception);
521  if (enum_values[i] == NULL)
522  {
523  freeargv (enum_values);
524  gdbscm_throw (exception);
525  }
526  ++i;
527  enum_values_scm = scm_cdr (enum_values_scm);
528  }
529  gdb_assert (i == size);
530 
531  result = gdbscm_gc_dup_argv (enum_values);
532  freeargv (enum_values);
533  return result;
534 }
535 
536 static const scheme_integer_constant parameter_types[] =
537 {
538  /* Note: var_integer is deprecated, and intentionally does not
539  appear here. */
540  { "PARAM_BOOLEAN", var_boolean }, /* ARI: var_boolean */
541  { "PARAM_AUTO_BOOLEAN", var_auto_boolean },
542  { "PARAM_ZINTEGER", var_zinteger },
543  { "PARAM_UINTEGER", var_uinteger },
544  { "PARAM_ZUINTEGER", var_zuinteger },
545  { "PARAM_ZUINTEGER_UNLIMITED", var_zuinteger_unlimited },
546  { "PARAM_STRING", var_string },
547  { "PARAM_STRING_NOESCAPE", var_string_noescape },
548  { "PARAM_OPTIONAL_FILENAME", var_optional_filename },
549  { "PARAM_FILENAME", var_filename },
550  { "PARAM_ENUM", var_enum },
551 
553 };
554 
555 /* Return non-zero if PARAM_TYPE is a valid parameter type. */
556 
557 static int
559 {
560  int i;
561 
562  for (i = 0; parameter_types[i].name != NULL; ++i)
563  {
564  if (parameter_types[i].value == param_type)
565  return 1;
566  }
567 
568  return 0;
569 }
570 
571 /* Return PARAM_TYPE as a string. */
572 
573 static const char *
575 {
576  int i;
577 
578  for (i = 0; parameter_types[i].name != NULL; ++i)
579  {
580  if (parameter_types[i].value == param_type)
581  return parameter_types[i].name;
582  }
583 
584  gdb_assert_not_reached ("bad parameter type");
585 }
586 
587 /* Return the value of a gdb parameter as a Scheme value.
588  If TYPE is not supported, then a <gdb:exception> object is returned. */
589 
590 static SCM
592  int arg_pos, const char *func_name)
593 {
594  /* Note: We *could* support var_integer here in case someone is trying to get
595  the value of a Python-created parameter (which is the only place that
596  still supports var_integer). To further discourage its use we do not. */
597 
598  switch (type)
599  {
600  case var_string:
601  case var_string_noescape:
603  case var_filename:
604  case var_enum:
605  {
606  char *str = * (char **) var;
607 
608  if (str == NULL)
609  str = "";
610  return gdbscm_scm_from_host_string (str, strlen (str));
611  }
612 
613  case var_boolean:
614  {
615  if (* (int *) var)
616  return SCM_BOOL_T;
617  else
618  return SCM_BOOL_F;
619  }
620 
621  case var_auto_boolean:
622  {
623  enum auto_boolean ab = * (enum auto_boolean *) var;
624 
625  if (ab == AUTO_BOOLEAN_TRUE)
626  return SCM_BOOL_T;
627  else if (ab == AUTO_BOOLEAN_FALSE)
628  return SCM_BOOL_F;
629  else
630  return auto_keyword;
631  }
632 
634  if (* (int *) var == -1)
635  return unlimited_keyword;
636  gdb_assert (* (int *) var >= 0);
637  /* Fall through. */
638  case var_zinteger:
639  return scm_from_int (* (int *) var);
640 
641  case var_uinteger:
642  if (* (unsigned int *) var == UINT_MAX)
643  return unlimited_keyword;
644  /* Fall through. */
645  case var_zuinteger:
646  return scm_from_uint (* (unsigned int *) var);
647 
648  default:
649  break;
650  }
651 
652  return gdbscm_make_out_of_range_error (func_name, arg_pos,
653  scm_from_int (type),
654  _("program error: unhandled type"));
655 }
656 
657 /* Set the value of a parameter of type TYPE in VAR from VALUE.
658  ENUMERATION is the list of enum values for enum parameters, otherwise NULL.
659  Throws a Scheme exception if VALUE_SCM is invalid for TYPE. */
660 
661 static void
663  const char * const *enumeration,
664  SCM value, int arg_pos, const char *func_name)
665 {
666  switch (type)
667  {
668  case var_string:
669  case var_string_noescape:
671  case var_filename:
672  SCM_ASSERT_TYPE (scm_is_string (value)
673  || (type != var_filename
674  && gdbscm_is_false (value)),
675  value, arg_pos, func_name,
676  _("string or #f for non-PARAM_FILENAME parameters"));
677  if (gdbscm_is_false (value))
678  {
679  xfree (var->stringval);
680  if (type == var_optional_filename)
681  var->stringval = xstrdup ("");
682  else
683  var->stringval = NULL;
684  }
685  else
686  {
687  char *string;
688  SCM exception;
689 
690  string = gdbscm_scm_to_host_string (value, NULL, &exception);
691  if (string == NULL)
692  gdbscm_throw (exception);
693  xfree (var->stringval);
694  var->stringval = string;
695  }
696  break;
697 
698  case var_enum:
699  {
700  int i;
701  char *str;
702  SCM exception;
703 
704  SCM_ASSERT_TYPE (scm_is_string (value), value, arg_pos, func_name,
705  _("string"));
706  str = gdbscm_scm_to_host_string (value, NULL, &exception);
707  if (str == NULL)
708  gdbscm_throw (exception);
709  for (i = 0; enumeration[i]; ++i)
710  {
711  if (strcmp (enumeration[i], str) == 0)
712  break;
713  }
714  xfree (str);
715  if (enumeration[i] == NULL)
716  {
717  gdbscm_out_of_range_error (func_name, arg_pos, value,
718  _("not member of enumeration"));
719  }
720  var->cstringval = enumeration[i];
721  break;
722  }
723 
724  case var_boolean:
725  SCM_ASSERT_TYPE (gdbscm_is_bool (value), value, arg_pos, func_name,
726  _("boolean"));
727  var->intval = gdbscm_is_true (value);
728  break;
729 
730  case var_auto_boolean:
731  SCM_ASSERT_TYPE (gdbscm_is_bool (value)
732  || scm_is_eq (value, auto_keyword),
733  value, arg_pos, func_name,
734  _("boolean or #:auto"));
735  if (scm_is_eq (value, auto_keyword))
737  else if (gdbscm_is_true (value))
739  else
741  break;
742 
743  case var_zinteger:
744  case var_uinteger:
745  case var_zuinteger:
747  if (type == var_uinteger
748  || type == var_zuinteger_unlimited)
749  {
750  SCM_ASSERT_TYPE (gdbscm_is_bool (value)
751  || scm_is_eq (value, unlimited_keyword),
752  value, arg_pos, func_name,
753  _("integer or #:unlimited"));
754  if (scm_is_eq (value, unlimited_keyword))
755  {
756  if (type == var_uinteger)
757  var->intval = UINT_MAX;
758  else
759  var->intval = -1;
760  break;
761  }
762  }
763  else
764  {
765  SCM_ASSERT_TYPE (scm_is_integer (value), value, arg_pos, func_name,
766  _("integer"));
767  }
768 
769  if (type == var_uinteger
770  || type == var_zuinteger)
771  {
772  unsigned int u = scm_to_uint (value);
773 
774  if (type == var_uinteger && u == 0)
775  u = UINT_MAX;
776  var->uintval = u;
777  }
778  else
779  {
780  int i = scm_to_int (value);
781 
782  if (type == var_zuinteger_unlimited && i < -1)
783  {
784  gdbscm_out_of_range_error (func_name, arg_pos, value,
785  _("must be >= -1"));
786  }
787  var->intval = i;
788  }
789  break;
790 
791  default:
792  gdb_assert_not_reached ("bad parameter type");
793  }
794 }
795 
796 /* Parameter Scheme functions. */
797 
798 /* (make-parameter name
799  [#:command-class cmd-class] [#:parameter-type param-type]
800  [#:enum-list enum-list] [#:set-func function] [#:show-func function]
801  [#:doc <string>] [#:set-doc <string>] [#:show-doc <string>]
802  [#:initial-value initial-value]) -> <gdb:parameter>
803 
804  NAME is the name of the parameter. It may consist of multiple
805  words, in which case the final word is the name of the new parameter,
806  and earlier words must be prefix commands.
807 
808  CMD-CLASS is the kind of command. It should be one of the COMMAND_*
809  constants defined in the gdb module.
810 
811  PARAM_TYPE is the type of the parameter. It should be one of the
812  PARAM_* constants defined in the gdb module.
813 
814  If PARAM-TYPE is PARAM_ENUM, then ENUM-LIST is a list of strings that
815  are the valid values for this parameter. The first value is the default.
816 
817  SET-FUNC, if provided, is called after the parameter is set.
818  It is a function of one parameter: the <gdb:parameter> object.
819  It must return a string to be displayed to the user.
820  Setting a parameter is typically a silent operation, so typically ""
821  should be returned.
822 
823  SHOW-FUNC, if provided, returns the string that is printed.
824  It is a function of two parameters: the <gdb:parameter> object
825  and the current value of the parameter as a string.
826 
827  DOC, SET-DOC, SHOW-DOC are the doc strings for the parameter.
828 
829  INITIAL-VALUE is the initial value of the parameter.
830 
831  The result is the <gdb:parameter> Scheme object.
832  The parameter is not available to be used yet, however.
833  It must still be added to gdb with register-parameter!. */
834 
835 static SCM
836 gdbscm_make_parameter (SCM name_scm, SCM rest)
837 {
838  const SCM keywords[] = {
842  initial_value_keyword, SCM_BOOL_F
843  };
844  int cmd_class_arg_pos = -1, param_type_arg_pos = -1;
845  int enum_list_arg_pos = -1, set_func_arg_pos = -1, show_func_arg_pos = -1;
846  int doc_arg_pos = -1, set_doc_arg_pos = -1, show_doc_arg_pos = -1;
847  int initial_value_arg_pos = -1;
848  char *s;
849  char *name;
850  int cmd_class = no_class;
851  int param_type = var_boolean; /* ARI: var_boolean */
852  SCM enum_list_scm = SCM_BOOL_F;
853  SCM set_func = SCM_BOOL_F, show_func = SCM_BOOL_F;
854  char *doc = NULL, *set_doc = NULL, *show_doc = NULL;
855  SCM initial_value_scm = SCM_BOOL_F;
856  const char * const *enum_list = NULL;
857  SCM p_scm;
858  param_smob *p_smob;
859 
860  gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, keywords, "s#iiOOOsssO",
861  name_scm, &name, rest,
862  &cmd_class_arg_pos, &cmd_class,
863  &param_type_arg_pos, &param_type,
864  &enum_list_arg_pos, &enum_list_scm,
865  &set_func_arg_pos, &set_func,
866  &show_func_arg_pos, &show_func,
867  &doc_arg_pos, &doc,
868  &set_doc_arg_pos, &set_doc,
869  &show_doc_arg_pos, &show_doc,
870  &initial_value_arg_pos, &initial_value_scm);
871 
872  /* If doc is NULL, leave it NULL. See add_setshow_cmd_full. */
873  if (set_doc == NULL)
874  set_doc = get_doc_string ();
875  if (show_doc == NULL)
876  show_doc = get_doc_string ();
877 
878  s = name;
879  name = gdbscm_canonicalize_command_name (s, 0);
880  xfree (s);
881  if (doc != NULL)
882  {
883  s = doc;
884  doc = gdbscm_gc_xstrdup (s);
885  xfree (s);
886  }
887  s = set_doc;
888  set_doc = gdbscm_gc_xstrdup (s);
889  xfree (s);
890  s = show_doc;
891  show_doc = gdbscm_gc_xstrdup (s);
892  xfree (s);
893 
894  if (!gdbscm_valid_command_class_p (cmd_class))
895  {
896  gdbscm_out_of_range_error (FUNC_NAME, cmd_class_arg_pos,
897  scm_from_int (cmd_class),
898  _("invalid command class argument"));
899  }
900  if (!pascm_valid_parameter_type_p (param_type))
901  {
902  gdbscm_out_of_range_error (FUNC_NAME, param_type_arg_pos,
903  scm_from_int (param_type),
904  _("invalid parameter type argument"));
905  }
906  if (enum_list_arg_pos > 0 && param_type != var_enum)
907  {
908  gdbscm_misc_error (FUNC_NAME, enum_list_arg_pos, enum_list_scm,
909  _("#:enum-values can only be provided with PARAM_ENUM"));
910  }
911  if (enum_list_arg_pos < 0 && param_type == var_enum)
912  {
914  _("PARAM_ENUM requires an enum-values argument"));
915  }
916  if (set_func_arg_pos > 0)
917  {
918  SCM_ASSERT_TYPE (gdbscm_is_procedure (set_func), set_func,
919  set_func_arg_pos, FUNC_NAME, _("procedure"));
920  }
921  if (show_func_arg_pos > 0)
922  {
923  SCM_ASSERT_TYPE (gdbscm_is_procedure (show_func), show_func,
924  show_func_arg_pos, FUNC_NAME, _("procedure"));
925  }
926  if (param_type == var_enum)
927  {
928  /* Note: enum_list lives in GC space, so we don't have to worry about
929  freeing it if we later throw an exception. */
930  enum_list = compute_enum_list (enum_list_scm, enum_list_arg_pos,
931  FUNC_NAME);
932  }
933 
934  /* If initial-value is a function, we need the parameter object constructed
935  to pass it to the function. A typical thing the function may want to do
936  is add an object-property to it to record the last known good value. */
937  p_scm = pascm_make_param_smob ();
938  p_smob = (param_smob *) SCM_SMOB_DATA (p_scm);
939  /* These are all stored in GC space so that we don't have to worry about
940  freeing them if we throw an exception. */
941  p_smob->name = name;
942  p_smob->cmd_class = cmd_class;
943  p_smob->type = (enum var_types) param_type;
944  p_smob->doc = doc;
945  p_smob->set_doc = set_doc;
946  p_smob->show_doc = show_doc;
947  p_smob->enumeration = enum_list;
948  p_smob->set_func = set_func;
949  p_smob->show_func = show_func;
950 
951  if (initial_value_arg_pos > 0)
952  {
953  if (gdbscm_is_procedure (initial_value_scm))
954  {
955  initial_value_scm = gdbscm_safe_call_1 (initial_value_scm,
956  p_smob->containing_scm, NULL);
957  if (gdbscm_is_exception (initial_value_scm))
958  gdbscm_throw (initial_value_scm);
959  }
960  pascm_set_param_value_x (param_type, &p_smob->value, enum_list,
961  initial_value_scm,
962  initial_value_arg_pos, FUNC_NAME);
963  }
964 
965  return p_scm;
966 }
967 
968 /* Subroutine of gdbscm_register_parameter_x to simplify it.
969  Return non-zero if parameter NAME is already defined in LIST. */
970 
971 static int
973 {
974  struct cmd_list_element *c;
975 
976  c = lookup_cmd_1 (&name, list, NULL, 1);
977 
978  /* If the name is ambiguous that's ok, it's a new parameter still. */
979  return c != NULL && c != CMD_LIST_AMBIGUOUS;
980 }
981 
982 /* (register-parameter! <gdb:parameter>) -> unspecified
983 
984  It is an error to register a pre-existing parameter. */
985 
986 static SCM
988 {
989  param_smob *p_smob
990  = pascm_get_param_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
991  char *cmd_name;
992  struct cmd_list_element **set_list, **show_list;
993 
994  if (pascm_is_valid (p_smob))
995  scm_misc_error (FUNC_NAME, _("parameter is already registered"), SCM_EOL);
996 
997  cmd_name = gdbscm_parse_command_name (p_smob->name, FUNC_NAME, SCM_ARG1,
998  &set_list, &setlist);
999  xfree (cmd_name);
1000  cmd_name = gdbscm_parse_command_name (p_smob->name, FUNC_NAME, SCM_ARG1,
1001  &show_list, &showlist);
1002  p_smob->cmd_name = gdbscm_gc_xstrdup (cmd_name);
1003  xfree (cmd_name);
1004 
1005  if (pascm_parameter_defined_p (p_smob->cmd_name, *set_list))
1006  {
1007  gdbscm_misc_error (FUNC_NAME, SCM_ARG1, self,
1008  _("parameter exists, \"set\" command is already defined"));
1009  }
1010  if (pascm_parameter_defined_p (p_smob->cmd_name, *show_list))
1011  {
1012  gdbscm_misc_error (FUNC_NAME, SCM_ARG1, self,
1013  _("parameter exists, \"show\" command is already defined"));
1014  }
1015 
1016  TRY
1017  {
1018  add_setshow_generic (p_smob->type, p_smob->cmd_class,
1019  p_smob->cmd_name, p_smob,
1020  p_smob->set_doc, p_smob->show_doc, p_smob->doc,
1021  (gdbscm_is_procedure (p_smob->set_func)
1022  ? pascm_set_func : NULL),
1023  (gdbscm_is_procedure (p_smob->show_func)
1024  ? pascm_show_func : NULL),
1025  set_list, show_list,
1026  &p_smob->set_command, &p_smob->show_command);
1027  }
1028  CATCH (except, RETURN_MASK_ALL)
1029  {
1030  GDBSCM_HANDLE_GDB_EXCEPTION (except);
1031  }
1032  END_CATCH
1033 
1034  /* Note: At this point the parameter exists in gdb.
1035  So no more errors after this point. */
1036 
1037  /* The owner of this parameter is not in GC-controlled memory, so we need
1038  to protect it from GC until the parameter is deleted. */
1039  scm_gc_protect_object (p_smob->containing_scm);
1040 
1041  return SCM_UNSPECIFIED;
1042 }
1043 
1044 /* (parameter-value <gdb:parameter>) -> value
1045  (parameter-value <string>) -> value */
1046 
1047 static SCM
1049 {
1050  SCM_ASSERT_TYPE (pascm_is_parameter (self) || scm_is_string (self),
1051  self, SCM_ARG1, FUNC_NAME, _("<gdb:parameter> or string"));
1052 
1053  if (pascm_is_parameter (self))
1054  {
1055  param_smob *p_smob = pascm_get_param_smob_arg_unsafe (self, SCM_ARG1,
1056  FUNC_NAME);
1057 
1058  return pascm_param_value (p_smob->type, &p_smob->value,
1059  SCM_ARG1, FUNC_NAME);
1060  }
1061  else
1062  {
1063  char *name;
1064  SCM except_scm;
1065  struct cmd_list_element *alias, *prefix, *cmd;
1066  const char *arg;
1067  char *newarg;
1068  int found = -1;
1069  struct gdb_exception except = exception_none;
1070 
1071  name = gdbscm_scm_to_host_string (self, NULL, &except_scm);
1072  if (name == NULL)
1073  gdbscm_throw (except_scm);
1074  newarg = concat ("show ", name, (char *) NULL);
1075  TRY
1076  {
1077  found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
1078  }
1079  CATCH (ex, RETURN_MASK_ALL)
1080  {
1081  except = ex;
1082  }
1083  END_CATCH
1084 
1085  xfree (name);
1086  xfree (newarg);
1087  GDBSCM_HANDLE_GDB_EXCEPTION (except);
1088  if (!found)
1089  {
1090  gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG1, self,
1091  _("parameter not found"));
1092  }
1093  if (cmd->var == NULL)
1094  {
1095  gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG1, self,
1096  _("not a parameter"));
1097  }
1098 
1099  return pascm_param_value (cmd->var_type, cmd->var, SCM_ARG1, FUNC_NAME);
1100  }
1101 }
1102 
1103 /* (set-parameter-value! <gdb:parameter> value) -> unspecified */
1104 
1105 static SCM
1107 {
1108  param_smob *p_smob = pascm_get_param_smob_arg_unsafe (self, SCM_ARG1,
1109  FUNC_NAME);
1110 
1111  pascm_set_param_value_x (p_smob->type, &p_smob->value, p_smob->enumeration,
1112  value, SCM_ARG2, FUNC_NAME);
1113 
1114  return SCM_UNSPECIFIED;
1115 }
1116 
1117 /* Initialize the Scheme parameter support. */
1118 
1119 static const scheme_function parameter_functions[] =
1120 {
1121  { "make-parameter", 1, 0, 1, gdbscm_make_parameter,
1122  "\
1123 Make a GDB parameter object.\n\
1124 \n\
1125  Arguments: name\n\
1126  [#:command-class <cmd-class>] [#:parameter-type <parameter-type>]\n\
1127  [#:enum-list <enum-list>]\n\
1128  [#:set-func function] [#:show-func function]\n\
1129  [#:doc string] [#:set-doc string] [#:show-doc string]\n\
1130  [#:initial-value initial-value]\n\
1131  name: The name of the command. It may consist of multiple words,\n\
1132  in which case the final word is the name of the new parameter, and\n\
1133  earlier words must be prefix commands.\n\
1134  cmd-class: The class of the command, one of COMMAND_*.\n\
1135  The default is COMMAND_NONE.\n\
1136  parameter-type: The kind of parameter, one of PARAM_*\n\
1137  The default is PARAM_BOOLEAN.\n\
1138  enum-list: If parameter-type is PARAM_ENUM, then this specifies the set\n\
1139  of values of the enum.\n\
1140  set-func: A function of one parameter: the <gdb:parameter> object.\n\
1141  Called *after* the parameter has been set. Returns either \"\" or a\n\
1142  non-empty string to be displayed to the user.\n\
1143  If non-empty, GDB will add a trailing newline.\n\
1144  show-func: A function of two parameters: the <gdb:parameter> object\n\
1145  and the string representation of the current value.\n\
1146  The result is a string to be displayed to the user.\n\
1147  GDB will add a trailing newline.\n\
1148  doc: The \"doc string\" of the parameter.\n\
1149  set-doc: The \"doc string\" when setting the parameter.\n\
1150  show-doc: The \"doc string\" when showing the parameter.\n\
1151  initial-value: The initial value of the parameter." },
1152 
1153  { "register-parameter!", 1, 0, 0, gdbscm_register_parameter_x,
1154  "\
1155 Register a <gdb:parameter> object with GDB." },
1156 
1157  { "parameter?", 1, 0, 0, gdbscm_parameter_p,
1158  "\
1159 Return #t if the object is a <gdb:parameter> object." },
1160 
1161  { "parameter-value", 1, 0, 0, gdbscm_parameter_value,
1162  "\
1163 Return the value of a <gdb:parameter> object\n\
1164 or any gdb parameter if param is a string naming the parameter." },
1165 
1166  { "set-parameter-value!", 2, 0, 0, gdbscm_set_parameter_value_x,
1167  "\
1168 Set the value of a <gdb:parameter> object.\n\
1169 \n\
1170  Arguments: <gdb:parameter> value" },
1171 
1173 };
1174 
1175 void
1177 {
1180  scm_set_smob_print (parameter_smob_tag, pascm_print_param_smob);
1181 
1182  gdbscm_define_integer_constants (parameter_types, 1);
1183  gdbscm_define_functions (parameter_functions, 1);
1184 
1185  command_class_keyword = scm_from_latin1_keyword ("command-class");
1186  parameter_type_keyword = scm_from_latin1_keyword ("parameter-type");
1187  enum_list_keyword = scm_from_latin1_keyword ("enum-list");
1188  set_func_keyword = scm_from_latin1_keyword ("set-func");
1189  show_func_keyword = scm_from_latin1_keyword ("show-func");
1190  doc_keyword = scm_from_latin1_keyword ("doc");
1191  set_doc_keyword = scm_from_latin1_keyword ("set-doc");
1192  show_doc_keyword = scm_from_latin1_keyword ("show-doc");
1193  initial_value_keyword = scm_from_latin1_keyword ("initial-value");
1194  auto_keyword = scm_from_latin1_keyword ("auto");
1195  unlimited_keyword = scm_from_latin1_keyword ("unlimited");
1196 }
const char * string
Definition: signals.c:50
void set_cmd_context(struct cmd_list_element *cmd, void *context)
Definition: cli-decode.c:141
char * gdbscm_canonicalize_command_name(const char *name, int want_trailing_space)
Definition: scm-cmd.c:601
static SCM scm_new_smob(scm_t_bits tc, scm_t_bits data)
static int pascm_is_parameter(SCM scm)
Definition: scm-param.c:190
struct _param_smob param_smob
void * get_cmd_context(struct cmd_list_element *cmd)
Definition: cli-decode.c:147
const char *const * gdbscm_gc_dup_argv(char **argv)
Definition: scm-utils.c:599
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:719
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
void gdbscm_define_functions(const scheme_function *, int is_public)
Definition: scm-utils.c:44
void xfree(void *)
Definition: common-utils.c:97
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:487
static SCM show_doc_keyword
Definition: scm-param.c:127
char * gdbscm_scm_to_host_string(SCM string, size_t *lenp, SCM *except)
Definition: scm-string.c:221
char * cmd_name
Definition: scm-param.c:73
SCM show_func
Definition: scm-param.c:106
static SCM gdbscm_set_parameter_value_x(SCM self, SCM value)
Definition: scm-param.c:1106
struct ui_file * gdb_stdout
Definition: main.c:71
const char * cstringval
Definition: scm-param.c:47
SCM set_func
Definition: scm-param.c:102
enum command_class cmd_class
Definition: scm-param.c:76
#define FUNC_NAME
const struct gdb_exception exception_none
struct cmd_list_element * set_command
Definition: scm-param.c:89
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, int ignore_help_classes)
Definition: cli-decode.c:1332
SCM gdbscm_make_out_of_range_error(const char *subr, int arg_pos, SCM bad_value, const char *error)
scm_t_bits gdbscm_make_smob_type(const char *name, size_t size)
Definition: scm-gsmob.c:102
#define gdbscm_is_bool(scm)
static scm_t_bits parameter_smob_tag
Definition: scm-param.c:117
#define _(String)
Definition: gdb_locale.h:40
static SCM gdbscm_parameter_value(SCM self)
Definition: scm-param.c:1048
struct cmd_list_element * lookup_cmd(const char **line, struct cmd_list_element *list, char *cmdtype, int allow_unknown, int ignore_help_classes)
Definition: cli-decode.c:1475
struct cmd_list_element * prefix
Definition: cli-decode.h:162
#define END_CATCH
var_types
Definition: command.h:60
int lookup_cmd_composition(const char *text, struct cmd_list_element **alias, struct cmd_list_element **prefix_cmd, struct cmd_list_element **cmd)
Definition: cli-decode.c:1671
int gdbscm_is_exception(SCM scm)
#define gdbscm_is_true(scm)
char * gdbscm_parse_command_name(const char *name, const char *func_name, int arg_pos, struct cmd_list_element ***base_list, struct cmd_list_element **start_list)
Definition: scm-cmd.c:480
#define GDBSCM_ARG_NONE
struct cmd_list_element * add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:604
static SCM unlimited_keyword
Definition: scm-param.c:130
static SCM doc_keyword
Definition: scm-param.c:125
#define TRY
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:516
static SCM set_func_keyword
Definition: scm-param.c:123
void gdbscm_init_gsmob(gdb_smob *base)
Definition: scm-gsmob.c:113
#define CATCH(EXCEPTION, MASK)
char * gdbscm_exception_message_to_string(SCM exception)
static struct parser_state * pstate
Definition: ada-exp.c:149
#define UINT_MAX
Definition: defs.h:505
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
SCM gdbscm_exception_key(SCM excp)
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:694
static void pascm_show_func(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: scm-param.c:314
#define gdbscm_is_false(scm)
static int pascm_parameter_defined_p(const char *name, struct cmd_list_element *list)
Definition: scm-param.c:972
SCM gdbscm_scm_from_host_string(const char *string, size_t len)
Definition: scm-string.c:231
SCM containing_scm
Definition: scm-param.c:111
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
static void add_setshow_generic(enum var_types param_type, enum command_class cmd_class, char *cmd_name, param_smob *self, char *set_doc, char *show_doc, char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list, struct cmd_list_element **set_cmd, struct cmd_list_element **show_cmd)
Definition: scm-param.c:357
excp_matcher_func gdbscm_user_error_p
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
char * show_doc
Definition: scm-param.c:83
enum auto_boolean autoboolval
Definition: scm-param.c:38
static SCM command_class_keyword
Definition: scm-param.c:120
__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
enum var_types type
Definition: scm-param.c:79
void cmd_sfunc_ftype(char *args, int from_tty, struct cmd_list_element *c)
Definition: command.h:154
Definition: gdbtypes.h:749
SCM gdbscm_safe_call_2(SCM proc, SCM arg0, SCM arg1, excp_matcher_func *ok_excps)
void gdbscm_throw(SCM exception) ATTRIBUTE_NORETURN
char * stringval
Definition: scm-param.c:44
char * name
Definition: scm-param.c:68
void add_setshow_string_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:585
static SCM initial_value_keyword
Definition: scm-param.c:128
static SCM enum_list_keyword
Definition: scm-param.c:122
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char *const * enumeration
Definition: scm-param.c:97
#define CMD_LIST_AMBIGUOUS
Definition: command.h:193
static SCM gdbscm_register_parameter_x(SCM self)
Definition: scm-param.c:987
static const char *const * compute_enum_list(SCM enum_values_scm, int arg_pos, const char *func_name)
Definition: scm-param.c:490
static void pascm_set_param_value_x(enum var_types type, union pascm_variable *var, const char *const *enumeration, SCM value, int arg_pos, const char *func_name)
Definition: scm-param.c:662
void * xmalloc(YYSIZE_T)
char * doc
Definition: scm-param.c:84
void( show_value_ftype)(struct ui_file *file, int from_tty, struct cmd_list_element *cmd, const char *value)
Definition: command.h:242
void gdbscm_printf(SCM port, const char *format,...) ATTRIBUTE_PRINTF(2
static const char param_smob_name[]
Definition: scm-param.c:114
static SCM set_doc_keyword
Definition: scm-param.c:126
static SCM pascm_make_param_smob(void)
Definition: scm-param.c:169
Definition: value.c:172
union pascm_variable value
Definition: scm-param.c:93
SCM gdbscm_safe_call_1(SCM proc, SCM arg0, excp_matcher_func *ok_excps)
char * set_doc
Definition: scm-param.c:82
void gdbscm_define_integer_constants(const scheme_integer_constant *, int is_public)
Definition: scm-utils.c:63
#define END_FUNCTIONS
static SCM gdbscm_parameter_p(SCM scm)
Definition: scm-param.c:198
void add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:736
command_class
Definition: command.h:33
void gdbscm_misc_error(const char *subr, int arg_pos, SCM bad_value, const char *error) ATTRIBUTE_NORETURN
void gdbscm_print_gdb_exception(SCM port, SCM exception)
static SCM pascm_param_value(enum var_types type, void *var, int arg_pos, const char *func_name)
Definition: scm-param.c:591
static char * get_doc_string(void)
Definition: scm-param.c:239
static void pascm_set_func(char *args, int from_tty, struct cmd_list_element *c)
Definition: scm-param.c:272
void gdbscm_out_of_range_error(const char *subr, int arg_pos, SCM bad_value, const char *error) ATTRIBUTE_NORETURN
static void pascm_signal_setshow_error(SCM exception, const char *msg)
Definition: scm-param.c:248
gdb_smob base
Definition: scm-param.c:65
void add_setshow_filename_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:563
void gdbscm_parse_function_args(const char *function_name, int beginning_arg_pos, const SCM *keywords, const char *format,...)
Definition: scm-utils.c:377
static int pascm_is_valid(param_smob *)
Definition: scm-param.c:230
auto_boolean
Definition: defs.h:196
static SCM gdbscm_make_parameter(SCM name_scm, SCM rest)
Definition: scm-param.c:836
#define GDBSCM_HANDLE_GDB_EXCEPTION(exception)
const char * doc
Definition: cli-decode.h:131
static SCM auto_keyword
Definition: scm-param.c:129
unsigned int uintval
Definition: scm-param.c:41
static param_smob * pascm_get_param_smob_arg_unsafe(SCM self, int arg_pos, const char *func_name)
Definition: scm-param.c:219
static const char * pascm_param_type_name(enum var_types type)
Definition: scm-param.c:574
struct cmd_list_element * show_command
Definition: scm-param.c:90
void gdbscm_initialize_parameters(void)
Definition: scm-param.c:1176
static int pascm_valid_parameter_type_p(int param_type)
Definition: scm-param.c:558
static int pascm_print_param_smob(SCM self, SCM port, scm_print_state *pstate)
Definition: scm-param.c:140
int gdbscm_is_procedure(SCM proc)
Definition: scm-utils.c:579
int gdbscm_valid_command_class_p(int command_class)
Definition: scm-cmd.c:579
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
static SCM parameter_type_keyword
Definition: scm-param.c:121
static SCM pascm_get_param_arg_unsafe(SCM self, int arg_pos, const char *func_name)
Definition: scm-param.c:207
void add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:626
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
char * gdbscm_gc_xstrdup(const char *)
Definition: scm-utils.c:587
static SCM show_func_keyword
Definition: scm-param.c:124
#define END_INTEGER_CONSTANTS