void mi_cmd_stack_list_variables (char *command, char **argv, int argc) { struct frame_info *frame; int raw_arg = 0; enum py_bt_status result = PY_BT_ERROR; int print_value; if (argc > 0) raw_arg = parse_no_frames_option (argv[0]); if (argc < 1 || argc > 2 || (argc == 2 && ! raw_arg) || (argc == 1 && raw_arg)) error (_("-stack-list-variables: Usage: " \ "[--no-frame-filters] PRINT_VALUES")); frame = get_selected_frame (NULL); print_value = mi_parse_print_values (argv[raw_arg]); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_ARGS | PRINT_LOCALS; result = apply_frame_filter (frame, flags, print_value, current_uiout, 0, 0); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS) { list_args_or_locals (all, print_value, frame); } }
void mi_cmd_stack_list_frames (char *command, char **argv, int argc) { int frame_low; int frame_high; int i; struct cleanup *cleanup_stack; struct frame_info *fi; enum py_bt_status result = PY_BT_ERROR; int raw_arg = 0; int oind = 0; enum opt { NO_FRAME_FILTERS }; static const struct mi_opt opts[] = { {"-no-frame-filters", NO_FRAME_FILTERS, 0}, { 0, 0, 0 } }; /* Parse arguments. In this instance we are just looking for --no-frame-filters. */ while (1) { char *oarg; int opt = mi_getopt ("-stack-list-frames", argc, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case NO_FRAME_FILTERS: raw_arg = oind; break; } } /* After the last option is parsed, there should either be low - high range, or no further arguments. */ if ((argc - oind != 0) && (argc - oind != 2)) error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]")); /* If there is a range, set it. */ if (argc - oind == 2) { frame_low = atoi (argv[0 + oind]); frame_high = atoi (argv[1 + oind]); } else { /* Called with no arguments, it means we want the whole backtrace. */ frame_low = -1; frame_high = -1; } /* Let's position fi on the frame at which to start the display. Could be the innermost frame if the whole stack needs displaying, or if frame_low is 0. */ for (i = 0, fi = get_current_frame (); fi && i < frame_low; i++, fi = get_prev_frame (fi)); if (fi == NULL) error (_("-stack-list-frames: Not enough frames in stack.")); cleanup_stack = make_cleanup_ui_out_list_begin_end (current_uiout, "stack"); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_FRAME_INFO; int py_frame_low = frame_low; /* We cannot pass -1 to frame_low, as that would signify a relative backtrace from the tail of the stack. So, in the case of frame_low == -1, assign and increment it. */ if (py_frame_low == -1) py_frame_low++; result = apply_frame_filter (get_current_frame (), flags, NO_VALUES, current_uiout, py_frame_low, frame_high); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS) { /* Now let's print the frames up to frame_high, or until there are frames in the stack. */ for (; fi && (i <= frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) { QUIT; /* Print the location and the address always, even for level 0. If args is 0, don't print the arguments. */ print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */, 0); } } do_cleanups (cleanup_stack); }
void mi_cmd_stack_list_variables (char *command, char **argv, int argc) { struct frame_info *frame; int raw_arg = 0; enum py_bt_status result = PY_BT_ERROR; int print_value; int oind = 0; int skip_unavailable = 0; if (argc > 1) { int i; enum opt { NO_FRAME_FILTERS, SKIP_UNAVAILABLE, }; static const struct mi_opt opts[] = { {"-no-frame-filters", NO_FRAME_FILTERS, 0}, {"-skip-unavailable", SKIP_UNAVAILABLE, 0}, { 0, 0, 0 } }; while (1) { char *oarg; /* Don't parse 'print-values' as an option. */ int opt = mi_getopt ("-stack-list-variables", argc - 1, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case NO_FRAME_FILTERS: raw_arg = oind; break; case SKIP_UNAVAILABLE: skip_unavailable = 1; break; } } } /* After the last option is parsed, there should be only 'print-values'. */ if (argc - oind != 1) error (_("-stack-list-variables: Usage: [--no-frame-filters] " \ "[--skip-unavailable] PRINT_VALUES")); frame = get_selected_frame (NULL); print_value = mi_parse_print_values (argv[oind]); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_ARGS | PRINT_LOCALS; result = apply_frame_filter (frame, flags, print_value, current_uiout, 0, 0); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS) { list_args_or_locals (all, print_value, frame, skip_unavailable); } }
void mi_cmd_stack_list_args (char *command, char **argv, int argc) { int frame_low; int frame_high; int i; struct frame_info *fi; struct cleanup *cleanup_stack_args; enum print_values print_values; struct ui_out *uiout = current_uiout; int raw_arg = 0; int oind = 0; int skip_unavailable = 0; enum py_bt_status result = PY_BT_ERROR; enum opt { NO_FRAME_FILTERS, SKIP_UNAVAILABLE, }; static const struct mi_opt opts[] = { {"-no-frame-filters", NO_FRAME_FILTERS, 0}, {"-skip-unavailable", SKIP_UNAVAILABLE, 0}, { 0, 0, 0 } }; while (1) { char *oarg; int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case NO_FRAME_FILTERS: raw_arg = oind; break; case SKIP_UNAVAILABLE: skip_unavailable = 1; break; } } if (argc - oind != 1 && argc - oind != 3) error (_("-stack-list-arguments: Usage: " \ "[--no-frame-filters] [--skip-unavailable] " "PRINT_VALUES [FRAME_LOW FRAME_HIGH]")); if (argc - oind == 3) { frame_low = atoi (argv[1 + oind]); frame_high = atoi (argv[2 + oind]); } else { /* Called with no arguments, it means we want args for the whole backtrace. */ frame_low = -1; frame_high = -1; } print_values = mi_parse_print_values (argv[oind]); /* Let's position fi on the frame at which to start the display. Could be the innermost frame if the whole stack needs displaying, or if frame_low is 0. */ for (i = 0, fi = get_current_frame (); fi && i < frame_low; i++, fi = get_prev_frame (fi)); if (fi == NULL) error (_("-stack-list-arguments: Not enough frames in stack.")); cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args"); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_ARGS; int py_frame_low = frame_low; /* We cannot pass -1 to frame_low, as that would signify a relative backtrace from the tail of the stack. So, in the case of frame_low == -1, assign and increment it. */ if (py_frame_low == -1) py_frame_low++; result = apply_frame_filter (get_current_frame (), flags, print_values, current_uiout, py_frame_low, frame_high); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS) { /* Now let's print the frames up to frame_high, or until there are frames in the stack. */ for (; fi && (i <= frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) { struct cleanup *cleanup_frame; QUIT; cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); ui_out_field_int (uiout, "level", i); list_args_or_locals (arguments, print_values, fi, skip_unavailable); do_cleanups (cleanup_frame); } } do_cleanups (cleanup_stack_args); }
void mi_cmd_stack_list_args (char *command, char **argv, int argc) { int frame_low; int frame_high; int i; struct frame_info *fi; struct cleanup *cleanup_stack_args; enum print_values print_values; struct ui_out *uiout = current_uiout; int raw_arg = 0; enum py_bt_status result = PY_BT_ERROR; if (argc > 0) raw_arg = parse_no_frames_option (argv[0]); if (argc < 1 || (argc > 3 && ! raw_arg) || (argc == 2 && ! raw_arg)) error (_("-stack-list-arguments: Usage: " \ "[--no-frame-filters] PRINT_VALUES [FRAME_LOW FRAME_HIGH]")); if (argc >= 3) { frame_low = atoi (argv[1 + raw_arg]); frame_high = atoi (argv[2 + raw_arg]); } else { /* Called with no arguments, it means we want args for the whole backtrace. */ frame_low = -1; frame_high = -1; } print_values = mi_parse_print_values (argv[raw_arg]); /* Let's position fi on the frame at which to start the display. Could be the innermost frame if the whole stack needs displaying, or if frame_low is 0. */ for (i = 0, fi = get_current_frame (); fi && i < frame_low; i++, fi = get_prev_frame (fi)); if (fi == NULL) error (_("-stack-list-arguments: Not enough frames in stack.")); cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args"); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_ARGS; int py_frame_low = frame_low; /* We cannot pass -1 to frame_low, as that would signify a relative backtrace from the tail of the stack. So, in the case of frame_low == -1, assign and increment it. */ if (py_frame_low == -1) py_frame_low++; result = apply_frame_filter (get_current_frame (), flags, print_values, current_uiout, py_frame_low, frame_high); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS) { /* Now let's print the frames up to frame_high, or until there are frames in the stack. */ for (; fi && (i <= frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) { struct cleanup *cleanup_frame; QUIT; cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); ui_out_field_int (uiout, "level", i); list_args_or_locals (arguments, print_values, fi); do_cleanups (cleanup_frame); } } do_cleanups (cleanup_stack_args); }