/* GDB parameters implemented in Guile.
- Copyright (C) 2008-2014 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "value.h"
-#include "exceptions.h"
#include "charset.h"
#include "gdbcmd.h"
#include "cli/cli-decode.h"
union pascm_variable
{
- /* Hold an integer value, for boolean and integer types. */
+ /* Hold an boolean value. */
+ bool boolval;
+
+ /* Hold an integer value. */
int intval;
/* Hold an auto_boolean. */
if (! pascm_is_valid (p_smob))
scm_puts (" {invalid}", port);
- gdbscm_printf (port, " %s", pascm_param_type_name (p_smob->type));
+ gdbscm_printf (port, " %s ", pascm_param_type_name (p_smob->type));
value = pascm_param_value (p_smob->type, &p_smob->value,
GDBSCM_ARG_NONE, NULL);
memset (p_smob, 0, sizeof (*p_smob));
p_smob->cmd_class = no_class;
- p_smob->type = var_boolean;
+ p_smob->type = var_boolean; /* ARI: var_boolean */
p_smob->set_func = SCM_BOOL_F;
p_smob->show_func = SCM_BOOL_F;
p_scm = scm_new_smob (parameter_smob_tag, (scm_t_bits) p_smob);
itself. */
if (gdbscm_user_error_p (gdbscm_exception_key (exception)))
{
- char *excp_text = gdbscm_exception_message_to_string (exception);
+ gdb::unique_xmalloc_ptr<char> excp_text
+ = gdbscm_exception_message_to_string (exception);
- make_cleanup (xfree, excp_text);
- error ("%s", excp_text);
+ error ("%s", excp_text.get ());
}
else
{
Note: ARGS is always passed as NULL. */
static void
-pascm_set_func (char *args, int from_tty, struct cmd_list_element *c)
+pascm_set_func (const char *args, int from_tty, struct cmd_list_element *c)
{
param_smob *p_smob = (param_smob *) get_cmd_context (c);
SCM self, result, exception;
- char *msg;
- struct cleanup *cleanups;
gdb_assert (gdbscm_is_procedure (p_smob->set_func));
if (!scm_is_string (result))
error (_("Result of %s set-func is not a string."), p_smob->name);
- msg = gdbscm_scm_to_host_string (result, NULL, &exception);
+ gdb::unique_xmalloc_ptr<char> msg = gdbscm_scm_to_host_string (result, NULL,
+ &exception);
if (msg == NULL)
{
gdbscm_print_gdb_exception (SCM_BOOL_F, exception);
error (_("Error converting show text to host string."));
}
- cleanups = make_cleanup (xfree, msg);
/* GDB is usually silent when a parameter is set. */
- if (*msg != '\0')
- fprintf_filtered (gdb_stdout, "%s\n", msg);
- do_cleanups (cleanups);
+ if (*msg.get () != '\0')
+ fprintf_filtered (gdb_stdout, "%s\n", msg.get ());
}
/* A callback function that is registered against the respective
{
param_smob *p_smob = (param_smob *) get_cmd_context (c);
SCM value_scm, self, result, exception;
- char *msg;
- struct cleanup *cleanups;
gdb_assert (gdbscm_is_procedure (p_smob->show_func));
_("Error occurred showing parameter."));
}
- msg = gdbscm_scm_to_host_string (result, NULL, &exception);
+ gdb::unique_xmalloc_ptr<char> msg = gdbscm_scm_to_host_string (result, NULL,
+ &exception);
if (msg == NULL)
{
gdbscm_print_gdb_exception (SCM_BOOL_F, exception);
error (_("Error converting show text to host string."));
}
- cleanups = make_cleanup (xfree, msg);
- fprintf_filtered (file, "%s\n", msg);
- do_cleanups (cleanups);
+ fprintf_filtered (file, "%s\n", msg.get ());
}
/* A helper function that dispatches to the appropriate add_setshow
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,
+ cmd_const_sfunc_ftype *set_func,
show_value_ftype *show_func,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list,
{
case var_boolean:
add_setshow_boolean_cmd (cmd_name, cmd_class,
- &self->value.intval,
+ &self->value.boolval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
_("enumeration list is empty"));
}
- enum_values = xmalloc ((size + 1) * sizeof (char *));
- memset (enum_values, 0, (size + 1) * sizeof (char *));
+ enum_values = XCNEWVEC (char *, size + 1);
i = 0;
while (!scm_is_eq (enum_values_scm, SCM_EOL))
freeargv (enum_values);
SCM_ASSERT_TYPE (0, value, arg_pos, func_name, _("string"));
}
- enum_values[i] = gdbscm_scm_to_host_string (value, NULL, &exception);
+ enum_values[i] = gdbscm_scm_to_host_string (value, NULL,
+ &exception).release ();
if (enum_values[i] == NULL)
{
freeargv (enum_values);
case var_filename:
case var_enum:
{
- char *str = * (char **) var;
+ const char *str = *(char **) var;
if (str == NULL)
str = "";
case var_boolean:
{
- if (* (int *) var)
+ if (* (bool *) var)
return SCM_BOOL_T;
else
return SCM_BOOL_F;
}
else
{
- char *string;
SCM exception;
- string = gdbscm_scm_to_host_string (value, NULL, &exception);
+ gdb::unique_xmalloc_ptr<char> string
+ = gdbscm_scm_to_host_string (value, NULL, &exception);
if (string == NULL)
gdbscm_throw (exception);
xfree (var->stringval);
- var->stringval = string;
+ var->stringval = string.release ();
}
break;
case var_enum:
{
int i;
- char *str;
SCM exception;
SCM_ASSERT_TYPE (scm_is_string (value), value, arg_pos, func_name,
_("string"));
- str = gdbscm_scm_to_host_string (value, NULL, &exception);
+ gdb::unique_xmalloc_ptr<char> str
+ = gdbscm_scm_to_host_string (value, NULL, &exception);
if (str == NULL)
gdbscm_throw (exception);
for (i = 0; enumeration[i]; ++i)
{
- if (strcmp (enumeration[i], str) == 0)
+ if (strcmp (enumeration[i], str.get ()) == 0)
break;
}
- xfree (str);
if (enumeration[i] == NULL)
{
gdbscm_out_of_range_error (func_name, arg_pos, value,
case var_boolean:
SCM_ASSERT_TYPE (gdbscm_is_bool (value), value, arg_pos, func_name,
_("boolean"));
- var->intval = gdbscm_is_true (value);
+ var->boolval = gdbscm_is_true (value);
break;
case var_auto_boolean:
char *s;
char *name;
int cmd_class = no_class;
- int param_type = var_boolean;
+ int param_type = var_boolean; /* ARI: var_boolean */
SCM enum_list_scm = SCM_BOOL_F;
SCM set_func = SCM_BOOL_F, show_func = SCM_BOOL_F;
char *doc = NULL, *set_doc = NULL, *show_doc = NULL;
/* These are all stored in GC space so that we don't have to worry about
freeing them if we throw an exception. */
p_smob->name = name;
- p_smob->cmd_class = cmd_class;
+ p_smob->cmd_class = (enum command_class) cmd_class;
p_smob->type = (enum var_types) param_type;
p_smob->doc = doc;
p_smob->set_doc = set_doc;
if (gdbscm_is_exception (initial_value_scm))
gdbscm_throw (initial_value_scm);
}
- pascm_set_param_value_x (param_type, &p_smob->value, enum_list,
+ pascm_set_param_value_x (p_smob->type, &p_smob->value, enum_list,
initial_value_scm,
initial_value_arg_pos, FUNC_NAME);
}
return p_scm;
}
+/* Subroutine of gdbscm_register_parameter_x to simplify it.
+ Return non-zero if parameter NAME is already defined in LIST. */
+
+static int
+pascm_parameter_defined_p (const char *name, struct cmd_list_element *list)
+{
+ struct cmd_list_element *c;
+
+ c = lookup_cmd_1 (&name, list, NULL, 1);
+
+ /* If the name is ambiguous that's ok, it's a new parameter still. */
+ return c != NULL && c != CMD_LIST_AMBIGUOUS;
+}
+
/* (register-parameter! <gdb:parameter>) -> unspecified
- It is an error to register a parameter more than once. */
+ It is an error to register a pre-existing parameter. */
static SCM
gdbscm_register_parameter_x (SCM self)
= pascm_get_param_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
char *cmd_name;
struct cmd_list_element **set_list, **show_list;
- volatile struct gdb_exception except;
if (pascm_is_valid (p_smob))
scm_misc_error (FUNC_NAME, _("parameter is already registered"), SCM_EOL);
p_smob->cmd_name = gdbscm_gc_xstrdup (cmd_name);
xfree (cmd_name);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ if (pascm_parameter_defined_p (p_smob->cmd_name, *set_list))
+ {
+ gdbscm_misc_error (FUNC_NAME, SCM_ARG1, self,
+ _("parameter exists, \"set\" command is already defined"));
+ }
+ if (pascm_parameter_defined_p (p_smob->cmd_name, *show_list))
+ {
+ gdbscm_misc_error (FUNC_NAME, SCM_ARG1, self,
+ _("parameter exists, \"show\" command is already defined"));
+ }
+
+ gdbscm_gdb_exception exc {};
+ try
{
add_setshow_generic (p_smob->type, p_smob->cmd_class,
p_smob->cmd_name, p_smob,
set_list, show_list,
&p_smob->set_command, &p_smob->show_command);
}
- GDBSCM_HANDLE_GDB_EXCEPTION (except);
+ catch (const gdb_exception &except)
+ {
+ exc = unpack (except);
+ }
+ GDBSCM_HANDLE_GDB_EXCEPTION (exc);
/* Note: At this point the parameter exists in gdb.
So no more errors after this point. */
}
else
{
- char *name;
SCM except_scm;
struct cmd_list_element *alias, *prefix, *cmd;
- const char *arg;
char *newarg;
int found = -1;
- volatile struct gdb_exception except;
+ gdbscm_gdb_exception except {};
- name = gdbscm_scm_to_host_string (self, NULL, &except_scm);
+ gdb::unique_xmalloc_ptr<char> name
+ = gdbscm_scm_to_host_string (self, NULL, &except_scm);
if (name == NULL)
gdbscm_throw (except_scm);
- newarg = concat ("show ", name, (char *) NULL);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ newarg = concat ("show ", name.get (), (char *) NULL);
+ try
{
found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
}
- xfree (name);
+ catch (const gdb_exception &ex)
+ {
+ except = unpack (ex);
+ }
+
xfree (newarg);
GDBSCM_HANDLE_GDB_EXCEPTION (except);
if (!found)
static const scheme_function parameter_functions[] =
{
- { "make-parameter", 1, 0, 1, gdbscm_make_parameter,
+ { "make-parameter", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_parameter),
"\
Make a GDB parameter object.\n\
\n\
show-doc: The \"doc string\" when showing the parameter.\n\
initial-value: The initial value of the parameter." },
- { "register-parameter!", 1, 0, 0, gdbscm_register_parameter_x,
+ { "register-parameter!", 1, 0, 0,
+ as_a_scm_t_subr (gdbscm_register_parameter_x),
"\
Register a <gdb:parameter> object with GDB." },
- { "parameter?", 1, 0, 0, gdbscm_parameter_p,
+ { "parameter?", 1, 0, 0, as_a_scm_t_subr (gdbscm_parameter_p),
"\
Return #t if the object is a <gdb:parameter> object." },
- { "parameter-value", 1, 0, 0, gdbscm_parameter_value,
+ { "parameter-value", 1, 0, 0, as_a_scm_t_subr (gdbscm_parameter_value),
"\
Return the value of a <gdb:parameter> object\n\
or any gdb parameter if param is a string naming the parameter." },
- { "set-parameter-value!", 2, 0, 0, gdbscm_set_parameter_value_x,
+ { "set-parameter-value!", 2, 0, 0,
+ as_a_scm_t_subr (gdbscm_set_parameter_value_x),
"\
Set the value of a <gdb:parameter> object.\n\
\n\