static int
gdb_regformat (ClientData clientData, Tcl_Interp *interp,
int objc, Tcl_Obj **objv)
{
int fm, regno, numregs;
struct type *type;
if (objc != 3)
{
Tcl_WrongNumArgs (interp, 0, objv, "gdb_reginfo regno type format");
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (interp, objv[0], ®no) != TCL_OK)
return TCL_ERROR;
type = (struct type *)strtol (Tcl_GetStringFromObj (objv[1], NULL), NULL, 16);
fm = (int)*(Tcl_GetStringFromObj (objv[2], NULL));
numregs = (gdbarch_num_regs (get_current_arch ())
+ gdbarch_num_pseudo_regs (get_current_arch ()));
if (regno >= numregs)
{
gdbtk_set_result (interp, "Register number %d too large", regno);
return TCL_ERROR;
}
regformat[regno] = fm;
regtype[regno] = type;
return TCL_OK;
}
static int
map_arg_registers (Tcl_Interp *interp, int objc, Tcl_Obj **objv,
map_func func, map_arg arg)
{
int regnum, numregs;
/* Note that the test for a valid register must include checking the
gdbarch_register_name because gdbarch_num_regs may be allocated for
the union of the register sets within a family of related processors.
In this case, some entries of gdbarch_register_name will change
depending upon the particular processor being debugged. */
numregs = (gdbarch_num_regs (get_current_arch ())
+ gdbarch_num_pseudo_regs (get_current_arch ()));
if (objc == 0) /* No args, just do all the regs */
{
result_ptr->flags |= GDBTK_MAKES_LIST;
for (regnum = 0; regnum < numregs; regnum++)
{
if (gdbarch_register_name (get_current_arch (), regnum) == NULL
|| *(gdbarch_register_name (get_current_arch (), regnum)) == '\0')
continue;
func (regnum, arg);
}
return TCL_OK;
}
if (objc == 1)
if (Tcl_ListObjGetElements (interp, *objv, &objc, &objv ) != TCL_OK)
return TCL_ERROR;
if (objc > 1)
result_ptr->flags |= GDBTK_MAKES_LIST;
/* Else, list of register #s, just do listed regs */
for (; objc > 0; objc--, objv++)
{
if (Tcl_GetIntFromObj (NULL, *objv, ®num) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (regnum >= 0 && regnum < numregs)
func (regnum, arg);
else
{
Tcl_SetStringObj (result_ptr->obj_ptr, "bad register number", -1);
return TCL_ERROR;
}
}
return TCL_OK;
}
static void
setup_architecture_data ()
{
int numregs;
xfree (old_regs);
xfree (regformat);
xfree (regtype);
numregs = (gdbarch_num_regs (get_current_arch ())
+ gdbarch_num_pseudo_regs (get_current_arch ()));
old_regs = xcalloc (1, numregs * MAX_REGISTER_SIZE + 1);
regformat = (int *)xcalloc (numregs, sizeof(int));
regtype = (struct type **)xcalloc (numregs, sizeof(struct type **));
}
static void
extract_display_start_addr (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
{
enum tui_layout_type cur_layout = tui_current_layout ();
struct gdbarch *gdbarch = get_current_arch ();
CORE_ADDR addr;
CORE_ADDR pc;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
switch (cur_layout)
{
case SRC_COMMAND:
case SRC_DATA_COMMAND:
gdbarch = TUI_SRC_WIN->detail.source_info.gdbarch;
find_line_pc (cursal.symtab,
TUI_SRC_WIN->detail.source_info.start_line_or_addr.u.line_no,
&pc);
addr = pc;
break;
case DISASSEM_COMMAND:
case SRC_DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
gdbarch = TUI_DISASM_WIN->detail.source_info.gdbarch;
addr = TUI_DISASM_WIN->detail.source_info.start_line_or_addr.u.addr;
break;
default:
addr = 0;
break;
}
*gdbarch_p = gdbarch;
*addr_p = addr;
}
static void
get_register_size (int regnum, map_arg arg)
{
Tcl_ListObjAppendElement (gdbtk_interp, result_ptr->obj_ptr,
Tcl_NewIntObj (register_size (get_current_arch (),
regnum)));
}
static void
python_command (char *arg, int from_tty)
{
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
while (arg && *arg && isspace (*arg))
++arg;
if (arg && *arg)
{
if (PyRun_SimpleString (arg))
error (_("Error while executing Python code."));
}
else
{
struct command_line *l = get_command_line (python_control, "");
make_cleanup_free_command_lines (&l);
execute_control_command_untraced (l);
}
do_cleanups (cleanup);
}
/* This is the sfunc for the 'set charset' command. */
static void
set_charset_sfunc (char *charset, int from_tty,
struct cmd_list_element *c)
{
/* CAREFUL: set the target charset here as well. */
target_charset_name = host_charset_name;
validate (get_current_arch ());
}
void
mi_cmd_catch_assert (char *cmd, char *argv[], int argc)
{
struct gdbarch *gdbarch = get_current_arch();
char *condition = NULL;
int enabled = 1;
int temp = 0;
int oind = 0;
char *oarg;
enum opt
{
OPT_CONDITION, OPT_DISABLED, OPT_TEMP,
};
static const struct mi_opt opts[] =
{
{ "c", OPT_CONDITION, 1},
{ "d", OPT_DISABLED, 0 },
{ "t", OPT_TEMP, 0 },
{ 0, 0, 0 }
};
for (;;)
{
int opt = mi_getopt ("-catch-assert", argc, argv, opts,
&oind, &oarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case OPT_CONDITION:
condition = oarg;
break;
case OPT_DISABLED:
enabled = 0;
break;
case OPT_TEMP:
temp = 1;
break;
}
}
/* This command does not accept any argument. Make sure the user
did not provide any. */
if (oind != argc)
error (_("Invalid argument: %s"), argv[oind]);
setup_breakpoint_reporting ();
/* create_ada_exception_catchpoint needs CONDITION to be xstrdup'ed,
and will assume control of its lifetime. */
if (condition != NULL)
condition = xstrdup (condition);
create_ada_exception_catchpoint (gdbarch, ada_catch_assert,
NULL, condition, temp, enabled, 0);
}
static SCM
vlscm_unop (enum valscm_unary_opcode opcode, SCM x, const char *func_name)
{
struct gdbarch *gdbarch = get_current_arch ();
const struct language_defn *language = current_language;
struct value *arg1;
SCM result = SCM_BOOL_F;
struct value *res_val = NULL;
SCM except_scm;
struct cleanup *cleanups;
cleanups = make_cleanup_value_free_to_mark (value_mark ());
arg1 = vlscm_convert_value_from_scheme (func_name, SCM_ARG1, x,
&except_scm, gdbarch, language);
if (arg1 == NULL)
{
do_cleanups (cleanups);
gdbscm_throw (except_scm);
}
TRY
{
switch (opcode)
{
case VALSCM_NOT:
/* Alas gdb and guile use the opposite meaning for "logical not". */
{
struct type *type = language_bool_type (language, gdbarch);
res_val
= value_from_longest (type, (LONGEST) value_logical_not (arg1));
}
break;
case VALSCM_NEG:
res_val = value_neg (arg1);
break;
case VALSCM_NOP:
/* Seemingly a no-op, but if X was a Scheme value it is now
a <gdb:value> object. */
res_val = arg1;
break;
case VALSCM_ABS:
if (value_less (arg1, value_zero (value_type (arg1), not_lval)))
res_val = value_neg (arg1);
else
res_val = arg1;
break;
case VALSCM_LOGNOT:
res_val = value_complement (arg1);
break;
default:
gdb_assert_not_reached ("unsupported operation");
}
}
CATCH (except, RETURN_MASK_ALL)
{
GDBSCM_HANDLE_GDB_EXCEPTION_WITH_CLEANUPS (except, cleanups);
}
static void
core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request)
{
struct gdbarch *gdbarch = get_current_arch ();
/* Since this is the core file target, call the 'core_info_proc'
method on gdbarch, not 'info_proc'. */
if (gdbarch_core_info_proc_p (gdbarch))
gdbarch_core_info_proc (gdbarch, args, request);
}
static void
register_changed_p (int regnum, map_arg arg)
{
char raw_buffer[MAX_REGISTER_SIZE];
if (!target_has_registers
|| !frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
return;
if (memcmp (&old_regs[regnum * MAX_REGISTER_SIZE], raw_buffer,
register_size (get_current_arch (), regnum)) == 0)
return;
/* Found a changed register. Save new value and return its number. */
memcpy (&old_regs[regnum * MAX_REGISTER_SIZE], raw_buffer,
register_size (get_current_arch (), regnum));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, Tcl_NewIntObj (regnum));
}
void
mi_cmd_catch_assert (const char *cmd, char *argv[], int argc)
{
struct gdbarch *gdbarch = get_current_arch();
std::string condition;
int enabled = 1;
int temp = 0;
int oind = 0;
char *oarg;
enum opt
{
OPT_CONDITION, OPT_DISABLED, OPT_TEMP,
};
static const struct mi_opt opts[] =
{
{ "c", OPT_CONDITION, 1},
{ "d", OPT_DISABLED, 0 },
{ "t", OPT_TEMP, 0 },
{ 0, 0, 0 }
};
for (;;)
{
int opt = mi_getopt ("-catch-assert", argc, argv, opts,
&oind, &oarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case OPT_CONDITION:
condition.assign (oarg);
break;
case OPT_DISABLED:
enabled = 0;
break;
case OPT_TEMP:
temp = 1;
break;
}
}
/* This command does not accept any argument. Make sure the user
did not provide any. */
if (oind != argc)
error (_("Invalid argument: %s"), argv[oind]);
scoped_restore restore_breakpoint_reporting = setup_breakpoint_reporting ();
create_ada_exception_catchpoint (gdbarch, ada_catch_assert, std::string (),
condition, temp, enabled, 0);
}
static int
gdb_reggroup (ClientData clientData, Tcl_Interp *interp,
int objc, Tcl_Obj **objv)
{
struct reggroup *group;
char *groupname;
int regnum, num;
if (objc != 1)
{
Tcl_WrongNumArgs (interp, 0, objv, "gdb_reginfo group groupname");
return TCL_ERROR;
}
groupname = Tcl_GetStringFromObj (objv[0], NULL);
if (groupname == NULL)
{
gdbtk_set_result (interp, "could not read groupname");
return TCL_ERROR;
}
for (group = reggroup_next (get_current_arch (), NULL);
group != NULL;
group = reggroup_next (get_current_arch (), group))
{
if (strcmp (groupname, reggroup_name (group)) == 0)
break;
}
if (group == NULL)
return TCL_ERROR;
num = (gdbarch_num_regs (get_current_arch ())
+ gdbarch_num_pseudo_regs (get_current_arch ()));
for (regnum = 0; regnum < num; regnum++)
{
if (gdbarch_register_reggroup_p (get_current_arch (), regnum, group))
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, Tcl_NewIntObj (regnum));
}
return TCL_OK;
}
static void
py_free_pspace (struct program_space *pspace, void *datum)
{
struct cleanup *cleanup;
pspace_object *object = datum;
struct gdbarch *arch = get_current_arch ();
cleanup = ensure_python_env (arch, current_language);
object->pspace = NULL;
Py_DECREF ((PyObject *) object);
do_cleanups (cleanup);
}
static void
show_architecture (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
if (target_architecture_user == NULL)
fprintf_filtered (file, _("The target architecture is set "
"automatically (currently %s)\n"),
gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
else
fprintf_filtered (file, _("The target architecture is assumed to be %s\n"),
set_architecture_string);
}
bool
core_target::info_proc (const char *args, enum info_proc_what request)
{
struct gdbarch *gdbarch = get_current_arch ();
/* Since this is the core file target, call the 'core_info_proc'
method on gdbarch, not 'info_proc'. */
if (gdbarch_core_info_proc_p (gdbarch))
gdbarch_core_info_proc (gdbarch, args, request);
return true;
}
static SCM
gdbscm_register_breakpoint_x (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
volatile struct gdb_exception except;
/* We only support registering breakpoints created with make-breakpoint. */
if (!bp_smob->is_scheme_bkpt)
scm_misc_error (FUNC_NAME, _("not a Scheme breakpoint"), SCM_EOL);
if (bpscm_is_valid (bp_smob))
scm_misc_error (FUNC_NAME, _("breakpoint is already registered"), SCM_EOL);
pending_breakpoint_scm = self;
TRY_CATCH (except, RETURN_MASK_ALL)
{
char *location = bp_smob->spec.location;
int internal = bp_smob->spec.is_internal;
switch (bp_smob->spec.type)
{
case bp_breakpoint:
{
create_breakpoint (get_current_arch (),
location, NULL, -1, NULL,
0,
0, bp_breakpoint,
0,
AUTO_BOOLEAN_TRUE,
&bkpt_breakpoint_ops,
0, 1, internal, 0);
break;
}
case bp_watchpoint:
{
enum target_hw_bp_type access_type = bp_smob->spec.access_type;
if (access_type == hw_write)
watch_command_wrapper (location, 0, internal);
else if (access_type == hw_access)
awatch_command_wrapper (location, 0, internal);
else if (access_type == hw_read)
rwatch_command_wrapper (location, 0, internal);
else
gdb_assert_not_reached ("invalid access type");
break;
}
default:
gdb_assert_not_reached ("invalid breakpoint type");
}
}
static void
show_target_charset_name (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
if (!strcmp (value, "auto"))
fprintf_filtered (file,
_("The target character set is \"auto; "
"currently %s\".\n"),
gdbarch_auto_charset (get_current_arch ()));
else
fprintf_filtered (file, _("The target character set is \"%s\".\n"),
value);
}
static int
gdb_reggrouplist (ClientData clientData, Tcl_Interp *interp,
int objc, Tcl_Obj **objv)
{
struct reggroup *group;
int i = 0;
if (objc != 0)
{
Tcl_WrongNumArgs (interp, 0, objv, "gdb_reginfo grouplist");
return TCL_ERROR;
}
for (group = reggroup_next (get_current_arch (), NULL);
group != NULL;
group = reggroup_next (get_current_arch (), group))
{
if (reggroup_type (group) == USER_REGGROUP)
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, Tcl_NewStringObj (reggroup_name (group), -1));
}
return TCL_OK;
}
static void
get_register_types (int regnum, map_arg arg)
{
struct type *reg_vtype;
int i,n;
reg_vtype = register_type (get_current_arch (), regnum);
if (TYPE_CODE (reg_vtype) == TYPE_CODE_UNION)
{
n = TYPE_NFIELDS (reg_vtype);
/* limit to 16 types */
if (n > 16)
n = 16;
for (i = 0; i < n; i++)
{
Tcl_Obj *ar[3], *list;
char *buff;
buff = xstrprintf ("%lx", (long)TYPE_FIELD_TYPE (reg_vtype, i));
ar[0] = Tcl_NewStringObj (TYPE_FIELD_NAME (reg_vtype, i), -1);
ar[1] = Tcl_NewStringObj (buff, -1);
if (TYPE_CODE (TYPE_FIELD_TYPE (reg_vtype, i)) == TYPE_CODE_FLT)
ar[2] = Tcl_NewStringObj ("float", -1);
else
ar[2] = Tcl_NewStringObj ("int", -1);
list = Tcl_NewListObj (3, ar);
Tcl_ListObjAppendElement (gdbtk_interp, result_ptr->obj_ptr, list);
xfree (buff);
}
}
else
{
Tcl_Obj *ar[3], *list;
char *buff;
buff = xstrprintf ("%lx", (long)reg_vtype);
ar[0] = Tcl_NewStringObj (TYPE_NAME(reg_vtype), -1);
ar[1] = Tcl_NewStringObj (buff, -1);
if (TYPE_CODE (reg_vtype) == TYPE_CODE_FLT)
ar[2] = Tcl_NewStringObj ("float", -1);
else
ar[2] = Tcl_NewStringObj ("int", -1);
list = Tcl_NewListObj (3, ar);
xfree (buff);
Tcl_ListObjAppendElement (gdbtk_interp, result_ptr->obj_ptr, list);
}
}
void
mi_cmd_info_ada_exceptions (char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
struct gdbarch *gdbarch = get_current_arch ();
char *regexp;
struct cleanup *old_chain;
VEC(ada_exc_info) *exceptions;
int ix;
struct ada_exc_info *info;
switch (argc)
{
case 0:
regexp = NULL;
break;
case 1:
regexp = argv[0];
break;
default:
error (_("Usage: -info-ada-exceptions [REGEXP]"));
break;
}
exceptions = ada_exceptions_list (regexp);
old_chain = make_cleanup (VEC_cleanup (ada_exc_info), &exceptions);
make_cleanup_ui_out_table_begin_end
(uiout, 2, VEC_length (ada_exc_info, exceptions), "ada-exceptions");
ui_out_table_header (uiout, 1, ui_left, "name", "Name");
ui_out_table_header (uiout, 1, ui_left, "address", "Address");
ui_out_table_body (uiout);
for (ix = 0; VEC_iterate(ada_exc_info, exceptions, ix, info); ix++)
{
struct cleanup *sub_chain;
sub_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", info->name);
ui_out_field_core_addr (uiout, "address", gdbarch, info->addr);
do_cleanups (sub_chain);
}
do_cleanups (old_chain);
}
static void
show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
const char *value)
{
if (user_osabi_state == osabi_auto)
fprintf_filtered (file,
_("The current OS ABI is \"auto\" "
"(currently \"%s\").\n"),
gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
else
fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
gdbarch_osabi_name (user_selected_osabi));
if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
gdbarch_osabi_name (GDB_OSABI_DEFAULT));
}
static void
tui_reg_next_command (char *arg, int from_tty)
{
struct gdbarch *gdbarch = get_current_arch ();
if (TUI_DATA_WIN != 0)
{
struct reggroup *group
= TUI_DATA_WIN->detail.data_display_info.current_group;
group = reggroup_next (gdbarch, group);
if (group == 0)
group = reggroup_next (gdbarch, 0);
if (group)
tui_show_registers (group);
}
}
static void
show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
const char *value)
{
if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently big endian)\n"));
else
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently little endian)\n"));
else
if (target_byte_order_user == BFD_ENDIAN_BIG)
fprintf_unfiltered (file,
_("The target is assumed to be big endian\n"));
else
fprintf_unfiltered (file,
_("The target is assumed to be little endian\n"));
}
void
eval_python_from_control_command (struct command_line *cmd)
{
int ret;
char *script;
struct cleanup *cleanup;
if (cmd->body_count != 1)
error (_("Invalid \"python\" block structure."));
cleanup = ensure_python_env (get_current_arch (), current_language);
script = compute_python_string (cmd->body_list[0]);
ret = PyRun_SimpleString (script);
xfree (script);
if (ret)
error (_("Error while executing Python code."));
do_cleanups (cleanup);
}
static void
python_on_normal_stop (struct bpstats *bs, int print_frame)
{
struct cleanup *cleanup;
enum gdb_signal stop_signal;
if (!gdb_python_initialized)
return;
if (!find_thread_ptid (inferior_ptid))
return;
stop_signal = inferior_thread ()->suspend.stop_signal;
cleanup = ensure_python_env (get_current_arch (), current_language);
if (emit_stop_event (bs, stop_signal) < 0)
gdbpy_print_stack ();
do_cleanups (cleanup);
}
static void
python_interactive_command (char *arg, int from_tty)
{
struct cleanup *cleanup;
int err;
cleanup = make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
arg = skip_spaces (arg);
ensure_python_env (get_current_arch (), current_language);
if (arg && *arg)
{
int len = strlen (arg);
char *script = xmalloc (len + 2);
strcpy (script, arg);
script[len] = '\n';
script[len + 1] = '\0';
err = eval_python_command (script);
xfree (script);
}
else
{
err = PyRun_InteractiveLoop (instream, "<stdin>");
dont_repeat ();
}
if (err)
{
gdbpy_print_stack ();
error (_("Error while executing Python code."));
}
do_cleanups (cleanup);
}
bfd *
open_bfd_matching_arch (bfd *archive_bfd, bfd_format expected_format)
{
enum gdb_osabi osabi;
bfd *abfd;
osabi = GDB_OSABI_UNINITIALIZED;
abfd = NULL;
osabi = gdbarch_osabi (get_current_arch ());
if ((osabi <= GDB_OSABI_UNKNOWN) || (osabi >= GDB_OSABI_INVALID))
osabi = gdbarch_lookup_osabi (archive_bfd);
// FIXME: gdbarch_lookup_osabi() doesn't work yet on archive_bfd, hardcode
if ((osabi <= GDB_OSABI_UNKNOWN) || (osabi >= GDB_OSABI_INVALID))
osabi = GDB_OSABI_DARWIN;
for (;;)
{
abfd = bfd_openr_next_archived_file (archive_bfd, abfd);
if (abfd == NULL)
break;
if (! bfd_check_format (abfd, expected_format))
continue;
if (osabi == gdbarch_lookup_osabi_from_bfd (abfd))
break;
}
// Copy the filename of the archive to the binary bfd.
if (abfd)
{
xfree(abfd->filename);
abfd->filename = archive_bfd->filename;
}
return abfd;
}
void
tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
{
struct tui_gen_win_info *locator;
struct tui_locator_element *element;
struct gdbarch *gdbarch = get_current_arch ();
CORE_ADDR addr;
locator = tui_locator_win_info_ptr ();
element = &((struct tui_win_element *)
locator->content[0])->which_element.locator;
if (element->addr == 0)
{
struct minimal_symbol *main_symbol;
/* Find address of the start of program.
Note: this should be language specific. */
main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
if (main_symbol == 0)
main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
if (main_symbol == 0)
main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
if (main_symbol)
addr = SYMBOL_VALUE_ADDRESS (main_symbol);
else
addr = 0;
}
else /* The target is executing. */
{
gdbarch = element->gdbarch;
addr = element->addr;
}
*gdbarch_p = gdbarch;
*addr_p = addr;
}
static void
get_register_name (int regnum, map_arg arg)
{
/* Non-zero if the caller wants the register numbers, too. */
int numbers = arg.integer;
Tcl_Obj *name
= Tcl_NewStringObj (gdbarch_register_name (get_current_arch (), regnum), -1);
Tcl_Obj *elt;
if (numbers)
{
/* Build a tuple of the form "{REGNAME NUMBER}", and append it to
our result. */
Tcl_Obj *array[2];
array[0] = name;
array[1] = Tcl_NewIntObj (regnum);
elt = Tcl_NewListObj (2, array);
}
else
elt = name;
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, elt);
}
