/* MI Command Set - stack commands.
- Copyright 2000, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008
+ Free Software Foundation, Inc.
Contributed by Cygnus Solutions (a Red Hat company).
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "target.h"
#include "mi-cmds.h"
#include "ui-out.h"
#include "symtab.h"
-
-/* FIXME: these should go in some .h file but stack.c doesn't have a
- corresponding .h file. These wrappers will be obsolete anyway, once
- we pull the plug on the sanitization. */
-extern void select_frame_command_wrapper (char *, int);
+#include "block.h"
+#include "stack.h"
+#include "dictionary.h"
+#include "gdb_string.h"
static void list_args_or_locals (int locals, int values, struct frame_info *fi);
int frame_low;
int frame_high;
int i;
+ struct cleanup *cleanup_stack;
struct frame_info *fi;
- if (!target_has_stack)
- error ("mi_cmd_stack_list_frames: No stack.");
-
if (argc > 2 || argc == 1)
- error ("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]");
+ error (_("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"));
if (argc == 2)
{
i++, fi = get_prev_frame (fi));
if (fi == NULL)
- error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
+ error (_("mi_cmd_stack_list_frames: Not enough frames in stack."));
- ui_out_list_begin (uiout, "stack");
+ cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "stack");
/* Now let;s print the frames up to frame_high, or until there are
frames in the stack. */
i++, fi = get_prev_frame (fi))
{
QUIT;
- /* level == i: always print the level 'i'
- source == LOC_AND_ADDRESS: print the location and the address
- always, even for level 0.
+ /* Print the location and the address always, even for level 0.
args == 0: don't print the arguments. */
- print_frame_info (fi /* frame info */ ,
- i /* level */ ,
- LOC_AND_ADDRESS /* source */ ,
- 0 /* args */ );
+ print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
}
- ui_out_list_end (uiout);
- if (i < frame_high)
- error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
+ do_cleanups (cleanup_stack);
return MI_CMD_DONE;
}
int i;
struct frame_info *fi;
- if (!target_has_stack)
- error ("mi_cmd_stack_info_depth: No stack.");
-
if (argc > 1)
- error ("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]");
+ error (_("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"));
if (argc == 1)
frame_high = atoi (argv[0]);
enum mi_cmd_result
mi_cmd_stack_list_locals (char *command, char **argv, int argc)
{
- if (argc != 1)
- error ("mi_cmd_stack_list_locals: Usage: PRINT_VALUES");
+ struct frame_info *frame;
+ enum print_values print_values;
- list_args_or_locals (1, atoi (argv[0]), selected_frame);
+ if (argc != 1)
+ error (_("mi_cmd_stack_list_locals: Usage: PRINT_VALUES"));
+
+ frame = get_selected_frame (NULL);
+
+ if (strcmp (argv[0], "0") == 0
+ || strcmp (argv[0], mi_no_values) == 0)
+ print_values = PRINT_NO_VALUES;
+ else if (strcmp (argv[0], "1") == 0
+ || strcmp (argv[0], mi_all_values) == 0)
+ print_values = PRINT_ALL_VALUES;
+ else if (strcmp (argv[0], "2") == 0
+ || strcmp (argv[0], mi_simple_values) == 0)
+ print_values = PRINT_SIMPLE_VALUES;
+ else
+ error (_("Unknown value for PRINT_VALUES: must be: \
+0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
+ mi_no_values, mi_all_values, mi_simple_values);
+ list_args_or_locals (1, print_values, frame);
return MI_CMD_DONE;
}
int frame_high;
int i;
struct frame_info *fi;
+ struct cleanup *cleanup_stack_args;
if (argc < 1 || argc > 3 || argc == 2)
- error ("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]");
+ error (_("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
if (argc == 3)
{
i++, fi = get_prev_frame (fi));
if (fi == NULL)
- error ("mi_cmd_stack_list_args: Not enough frames in stack.");
+ error (_("mi_cmd_stack_list_args: Not enough frames in stack."));
- ui_out_list_begin (uiout, "stack-args");
+ cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
/* Now let's print the frames up to frame_high, or until there are
frames in the stack. */
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
+ struct cleanup *cleanup_frame;
QUIT;
- ui_out_tuple_begin (uiout, "frame");
+ cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
ui_out_field_int (uiout, "level", i);
list_args_or_locals (0, atoi (argv[0]), fi);
- ui_out_tuple_end (uiout);
+ do_cleanups (cleanup_frame);
}
- ui_out_list_end (uiout);
- if (i < frame_high)
- error ("mi_cmd_stack_list_args: Not enough frames in stack.");
+ do_cleanups (cleanup_stack_args);
return MI_CMD_DONE;
}
{
struct block *block;
struct symbol *sym;
- int i, nsyms;
+ struct dict_iterator iter;
+ int nsyms;
+ struct cleanup *cleanup_list;
static struct ui_stream *stb = NULL;
+ struct type *type;
stb = ui_out_stream_new (uiout);
block = get_frame_block (fi, 0);
- ui_out_list_begin (uiout, locals ? "locals" : "args");
+ cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, locals ? "locals" : "args");
while (block != 0)
{
- ALL_BLOCK_SYMBOLS (block, i, sym)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
int print_me = 0;
case LOC_REGPARM_ADDR: /* indirect register arg */
case LOC_LOCAL_ARG: /* stack arg */
case LOC_BASEREG_ARG: /* basereg arg */
+ case LOC_COMPUTED_ARG: /* arg with computed location */
if (!locals)
print_me = 1;
break;
case LOC_BASEREG: /* basereg local */
case LOC_STATIC: /* static */
case LOC_REGISTER: /* register */
+ case LOC_COMPUTED: /* computed location */
if (locals)
print_me = 1;
break;
}
if (print_me)
{
- if (values)
- ui_out_tuple_begin (uiout, NULL);
- ui_out_field_string (uiout, "name", SYMBOL_NAME (sym));
+ struct cleanup *cleanup_tuple = NULL;
+ struct symbol *sym2;
+ struct value *val;
+ if (values != PRINT_NO_VALUES)
+ cleanup_tuple =
+ make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
- if (values)
- {
- struct symbol *sym2;
- if (!locals)
- sym2 = lookup_symbol (SYMBOL_NAME (sym),
- block, VAR_NAMESPACE,
- (int *) NULL,
- (struct symtab **) NULL);
- else
+ if (!locals)
+ sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
+ block, VAR_DOMAIN,
+ (int *) NULL,
+ (struct symtab **) NULL);
+ else
sym2 = sym;
- print_variable_value (sym2, fi, stb->stream);
+ switch (values)
+ {
+ case PRINT_SIMPLE_VALUES:
+ type = check_typedef (sym2->type);
+ type_print (sym2->type, "", stb->stream, -1);
+ ui_out_field_stream (uiout, "type", stb);
+ if (TYPE_CODE (type) != TYPE_CODE_ARRAY
+ && TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ {
+ val = read_var_value (sym2, fi);
+ common_val_print
+ (val, stb->stream, 0, 1, 0, Val_no_prettyprint);
+ ui_out_field_stream (uiout, "value", stb);
+ }
+ do_cleanups (cleanup_tuple);
+ break;
+ case PRINT_ALL_VALUES:
+ val = read_var_value (sym2, fi);
+ common_val_print
+ (val, stb->stream, 0, 1, 0, Val_no_prettyprint);
ui_out_field_stream (uiout, "value", stb);
- ui_out_tuple_end (uiout);
+ do_cleanups (cleanup_tuple);
+ break;
}
}
}
else
block = BLOCK_SUPERBLOCK (block);
}
- ui_out_list_end (uiout);
+ do_cleanups (cleanup_list);
ui_out_stream_delete (stb);
}
enum mi_cmd_result
mi_cmd_stack_select_frame (char *command, char **argv, int argc)
{
- if (!target_has_stack)
- error ("mi_cmd_stack_select_frame: No stack.");
+ if (argc == 0 || argc > 1)
+ error (_("mi_cmd_stack_select_frame: Usage: FRAME_SPEC"));
- if (argc > 1)
- error ("mi_cmd_stack_select_frame: Usage: [FRAME_SPEC]");
+ select_frame_command (argv[0], 1 /* not used */ );
+ return MI_CMD_DONE;
+}
- /* with no args, don't change frame */
- if (argc == 0)
- select_frame_command_wrapper (0, 1 /* not used */ );
- else
- select_frame_command_wrapper (argv[0], 1 /* not used */ );
+enum mi_cmd_result
+mi_cmd_stack_info_frame (char *command, char **argv, int argc)
+{
+ if (argc > 0)
+ error (_("mi_cmd_stack_info_frame: No arguments required"));
+
+ print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
return MI_CMD_DONE;
}
projects / deliverable / binutils-gdb.git / blobdiff