Merge GDB 7.5.1

gdb/mi/mi-main.c

 /* MI Command Set.
 
    Copyright (C) 2000-2005, 2007-2012 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 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    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, see <http://www.gnu.org/licenses/>.  */
 
-/* Work in progress.  */
-
 #include "defs.h"
 #include "arch-utils.h"
 #include "target.h"
 #include "inferior.h"
 #include "gdb_string.h"
 #include "exceptions.h"
 #include "top.h"
 #include "gdbthread.h"
 #include "mi-cmds.h"
 #include "mi-parse.h"
@@ skipping 30 matching lines @@
 #ifdef HAVE_GETRUSAGE
 struct rusage rusage;
 #endif
 
 enum
   {
     FROM_TTY = 0
   };
 
 int mi_debug_p;
+
 struct ui_file *raw_stdout;
 
-/* This is used to pass the current command timestamp
-   down to continuation routines.  */
+/* This is used to pass the current command timestamp down to
+   continuation routines.  */
 static struct mi_timestamp *current_command_ts;
 
 static int do_timings = 0;
 
 char *current_token;
-/* Few commands would like to know if options like --thread-group
-   were explicitly specified.  This variable keeps the current
-   parsed command including all option, and make it possible.  */
+/* Few commands would like to know if options like --thread-group were
+   explicitly specified.  This variable keeps the current parsed
+   command including all option, and make it possible.  */
 static struct mi_parse *current_context;
 
 int running_result_record_printed = 1;
 
 /* Flag indicating that the target has proceeded since the last
    command was issued.  */
 int mi_proceeded;
 
 extern void _initialize_mi_main (void);
 static void mi_cmd_execute (struct mi_parse *parse);
@@ skipping 75 matching lines @@
   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
     mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
   else
     mi_execute_async_cli_command ("finish", argv, argc);
 }
 
 void
 mi_cmd_exec_return (char *command, char **argv, int argc)
 {
   /* This command doesn't really execute the target, it just pops the
-     specified number of frames. */
+     specified number of frames.  */
   if (argc)
     /* Call return_command with from_tty argument equal to 0 so as to
        avoid being queried.  */
     return_command (*argv, 0);
   else
     /* Call return_command with from_tty argument equal to 0 so as to
        avoid being queried.  */
     return_command (NULL, 0);
 
   /* Because we have called return_command with from_tty = 0, we need
@@ skipping 12 matching lines @@
 proceed_thread (struct thread_info *thread, int pid)
 {
   if (!is_stopped (thread->ptid))
     return;
 
   if (pid != 0 && PIDGET (thread->ptid) != pid)
     return;
 
   switch_to_thread (thread->ptid);
   clear_proceed_status ();
-  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+  proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
 }
 
-
 static int
 proceed_thread_callback (struct thread_info *thread, void *arg)
 {
   int pid = *(int *)arg;
 
   proceed_thread (thread, pid);
   return 0;
 }
 
 static void
 exec_continue (char **argv, int argc)
 {
   if (non_stop)
     {
-      /* In non-stop mode, 'resume' always resumes a single thread.  Therefore,
-         to resume all threads of the current inferior, or all threads in all
-         inferiors, we need to iterate over threads.
+      /* In non-stop mode, 'resume' always resumes a single thread.
+         Therefore, to resume all threads of the current inferior, or
+         all threads in all inferiors, we need to iterate over
+         threads.
 
          See comment on infcmd.c:proceed_thread_callback for rationale.  */
       if (current_context->all || current_context->thread_group != -1)
         {
           int pid = 0;
           struct cleanup *back_to = make_cleanup_restore_current_thread ();
 
           if (!current_context->all)
             {
               struct inferior *inf
@@ skipping 13 matching lines @@
     {
       struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
 
       if (current_context->all)
         {
           sched_multi = 1;
           continue_1 (0);
         }
       else
         {
-          /* In all-stop mode, -exec-continue traditionally resumed either
-             all threads, or one thread, depending on the 'scheduler-locking'
-             variable.  Let's continue to do the same.  */
+          /* In all-stop mode, -exec-continue traditionally resumed
+             either all threads, or one thread, depending on the
+             'scheduler-locking' variable.  Let's continue to do the
+             same.  */
           continue_1 (1);
         }
       do_cleanups (back_to);
     }
 }
 
 static void
 exec_direction_forward (void *notused)
 {
   execution_direction = EXEC_FORWARD;
@@ skipping 34 matching lines @@
   if (!is_running (thread->ptid))
     return 0;
 
   if (PIDGET (thread->ptid) != pid)
     return 0;
 
   target_stop (thread->ptid);
   return 0;
 }
 
-/* Interrupt the execution of the target.  Note how we must play around
-   with the token variables, in order to display the current token in
-   the result of the interrupt command, and the previous execution
-   token when the target finally stops.  See comments in
+/* Interrupt the execution of the target.  Note how we must play
+   around with the token variables, in order to display the current
+   token in the result of the interrupt command, and the previous
+   execution token when the target finally stops.  See comments in
    mi_cmd_execute.  */
+
 void
 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
 {
   /* In all-stop mode, everything stops, so we don't need to try
      anything specific.  */
   if (!non_stop)
     {
       interrupt_target_1 (0);
       return;
     }
@@ skipping 160 matching lines @@
 
 void
 mi_cmd_thread_info (char *command, char **argv, int argc)
 {
   if (argc != 0 && argc != 1)
     error (_("Invalid MI command"));
 
   print_thread_info (current_uiout, argv[0], -1);
 }
 
+DEF_VEC_I(int);
+
 struct collect_cores_data
 {
   int pid;
 
   VEC (int) *cores;
 };
 
 static int
 collect_cores (struct thread_info *ti, void *xdata)
 {
@@ skipping 82 matching lines @@
 
       if (top_data->recurse)
         print_thread_info (uiout, NULL, inferior->pid);
 
       do_cleanups (back_to);
     }
 
   return 0;
 }
 
-/* Output a field named 'cores' with a list as the value.  The elements of
-   the list are obtained by splitting 'cores' on comma.  */
+/* Output a field named 'cores' with a list as the value.  The
+   elements of the list are obtained by splitting 'cores' on
+   comma.  */
 
 static void
 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
 {
   struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
                                                                 field_name);
   char *cores = xstrdup (xcores);
   char *p = cores;
 
   make_cleanup (xfree, cores);
@@ skipping 166 matching lines @@
 void
 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
 {
   struct ui_out *uiout = current_uiout;
   struct cleanup *back_to;
   int available = 0;
   int recurse = 0;
   VEC (int) *ids = 0;
 
   enum opt
+  {
+    AVAILABLE_OPT, RECURSE_OPT
+  };
+  static const struct mi_opt opts[] =
     {
-      AVAILABLE_OPT, RECURSE_OPT
+      {"-available", AVAILABLE_OPT, 0},
+      {"-recurse", RECURSE_OPT, 1},
+      { 0, 0, 0 }
     };
-  static const struct mi_opt opts[] =
-  {
-    {"-available", AVAILABLE_OPT, 0},
-    {"-recurse", RECURSE_OPT, 1},
-    { 0, 0, 0 }
-  };
 
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
 
   while (1)
     {
       int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
-                           &optind, &optarg);
+                           &oind, &oarg);
 
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case AVAILABLE_OPT:
           available = 1;
           break;
         case RECURSE_OPT:
-          if (strcmp (optarg, "0") == 0)
+          if (strcmp (oarg, "0") == 0)
             ;
-          else if (strcmp (optarg, "1") == 0)
+          else if (strcmp (oarg, "1") == 0)
             recurse = 1;
           else
             error (_("only '0' and '1' are valid values "
                      "for the '--recurse' option"));
           break;
         }
     }
 
-  for (; optind < argc; ++optind)
+  for (; oind < argc; ++oind)
     {
       char *end;
       int inf;
 
-      if (*(argv[optind]) != 'i')
-        error (_("invalid syntax of group id '%s'"), argv[optind]);
+      if (*(argv[oind]) != 'i')
+        error (_("invalid syntax of group id '%s'"), argv[oind]);
 
-      inf = strtoul (argv[optind] + 1, &end, 0);
+      inf = strtoul (argv[oind] + 1, &end, 0);
 
       if (*end != '\0')
-        error (_("invalid syntax of group id '%s'"), argv[optind]);
+        error (_("invalid syntax of group id '%s'"), argv[oind]);
       VEC_safe_push (int, ids, inf);
     }
   if (VEC_length (int, ids) > 1)
     qsort (VEC_address (int, ids),
            VEC_length (int, ids),
            sizeof (int), compare_positive_ints);
 
   back_to = make_cleanup (free_vector_of_ints, &ids);
 
   if (available)
     {
       list_available_thread_groups (ids, recurse);
     }
   else if (VEC_length (int, ids) == 1)
     {
-      /* Local thread groups, single id. */
+      /* Local thread groups, single id.  */
       int id = *VEC_address (int, ids);
       struct inferior *inf = find_inferior_id (id);
 
       if (!inf)
         error (_("Non-existent thread group id '%d'"), id);
       
       print_thread_info (uiout, NULL, inf->pid);
     }
   else
     {
@@ skipping 17 matching lines @@
 void
 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
 {
   struct gdbarch *gdbarch;
   struct ui_out *uiout = current_uiout;
   int regnum, numregs;
   int i;
   struct cleanup *cleanup;
 
   /* 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.  */
+     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.  */
 
   gdbarch = get_current_arch ();
   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 
   cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
 
   if (argc == 0)                /* No args, just do all the regs.  */
     {
       for (regnum = 0;
            regnum < numregs;
@@ skipping 29 matching lines @@
 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
 {
   static struct regcache *this_regs = NULL;
   struct ui_out *uiout = current_uiout;
   struct regcache *prev_regs;
   struct gdbarch *gdbarch;
   int regnum, numregs, changed;
   int i;
   struct cleanup *cleanup;
 
-  /* The last time we visited this function, the current frame's register
-     contents were saved in THIS_REGS.  Move THIS_REGS over to PREV_REGS,
-     and refresh THIS_REGS with the now-current register contents.  */
+  /* The last time we visited this function, the current frame's
+     register contents were saved in THIS_REGS.  Move THIS_REGS over
+     to PREV_REGS, and refresh THIS_REGS with the now-current register
+     contents.  */
 
   prev_regs = this_regs;
   this_regs = frame_save_as_regcache (get_selected_frame (NULL));
   cleanup = make_cleanup_regcache_xfree (prev_regs);
 
   /* 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.  */
+     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.  */
 
   gdbarch = get_regcache_arch (this_regs);
   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 
   make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
 
-  if (argc == 0)                /* No args, just do all the regs.  */
+  if (argc == 0)
     {
+      /* No args, just do all the regs.  */
       for (regnum = 0;
            regnum < numregs;
            regnum++)
         {
           if (gdbarch_register_name (gdbarch, regnum) == NULL
               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
             continue;
           changed = register_changed_p (regnum, prev_regs, this_regs);
           if (changed < 0)
             error (_("-data-list-changed-registers: "
@@ skipping 49 matching lines @@
     return 1;
   else if (this_status == REG_VALID)
     return memcmp (prev_buffer, this_buffer,
                    register_size (gdbarch, regnum)) != 0;
   else
     return 0;
 }
 
 /* Return a list of register number and value pairs.  The valid
    arguments expected are: a letter indicating the format in which to
-   display the registers contents.  This can be one of: x (hexadecimal), d
-   (decimal), N (natural), t (binary), o (octal), r (raw).  After the
-   format argumetn there can be a sequence of numbers, indicating which
-   registers to fetch the content of.  If the format is the only argument,
-   a list of all the registers with their values is returned.  */
+   display the registers contents.  This can be one of: x
+   (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
+   (raw).  After the format argument there can be a sequence of
+   numbers, indicating which registers to fetch the content of.  If
+   the format is the only argument, a list of all the registers with
+   their values is returned.  */
+
 void
 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
 {
   struct ui_out *uiout = current_uiout;
   struct frame_info *frame;
   struct gdbarch *gdbarch;
   int regnum, numregs, format;
   int i;
   struct cleanup *list_cleanup, *tuple_cleanup;
 
   /* 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.  */
+     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.  */
 
   if (argc == 0)
     error (_("-data-list-register-values: Usage: "
              "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
 
   format = (int) argv[0][0];
 
   frame = get_selected_frame (NULL);
   gdbarch = get_frame_arch (frame);
   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 
   list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
 
-  if (argc == 1)            /* No args, beside the format: do all the regs.  */
+  if (argc == 1)
     {
+      /* No args, beside the format: do all the regs.  */
       for (regnum = 0;
            regnum < numregs;
            regnum++)
         {
           if (gdbarch_register_name (gdbarch, regnum) == NULL
               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
             continue;
           tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
           ui_out_field_int (uiout, "number", regnum);
           get_register (frame, regnum, format);
@@ skipping 16 matching lines @@
           get_register (frame, regnum, format);
           do_cleanups (tuple_cleanup);
         }
       else
         error (_("bad register number"));
     }
   do_cleanups (list_cleanup);
 }
 
 /* Output one register's contents in the desired format.  */
+
 static void
 get_register (struct frame_info *frame, int regnum, int format)
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   struct ui_out *uiout = current_uiout;
-  CORE_ADDR addr;
-  enum lval_type lval;
-  struct ui_stream *stb;
   struct value *val;
 
-  stb = ui_out_stream_new (uiout);
-
   if (format == 'N')
     format = 0;
 
   val = get_frame_register_value (frame, regnum);
 
   if (value_optimized_out (val))
     error (_("Optimized out"));
 
   if (format == 'r')
     {
       int j;
       char *ptr, buf[1024];
       const gdb_byte *valaddr = value_contents_for_printing (val);
 
       strcpy (buf, "0x");
       ptr = buf + 2;
       for (j = 0; j < register_size (gdbarch, regnum); j++)
         {
           int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
                     j : register_size (gdbarch, regnum) - 1 - j;
 
           sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
           ptr += 2;
         }
       ui_out_field_string (uiout, "value", buf);
-      /*fputs_filtered (buf, gdb_stdout); */
     }
   else
     {
       struct value_print_options opts;
+      struct ui_file *stb;
+      struct cleanup *old_chain;
+
+      stb = mem_fileopen ();
+      old_chain = make_cleanup_ui_file_delete (stb);
 
       get_formatted_print_options (&opts, format);
       opts.deref_ref = 1;
       val_print (value_type (val),
                  value_contents_for_printing (val),
                  value_embedded_offset (val), 0,
-                 stb->stream, 0, val, &opts, current_language);
+                 stb, 0, val, &opts, current_language);
       ui_out_field_stream (uiout, "value", stb);
-      ui_out_stream_delete (stb);
+      do_cleanups (old_chain);
     }
 }
 
 /* Write given values into registers. The registers and values are
    given as pairs.  The corresponding MI command is 
    -data-write-register-values <format>
                                [<regnum1> <value1>...<regnumN> <valueN>] */
 void
 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
 {
   struct regcache *regcache;
   struct gdbarch *gdbarch;
   int numregs, i;
   char format;
 
   /* 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.  */
+     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.  */
 
   regcache = get_current_regcache ();
   gdbarch = get_regcache_arch (regcache);
   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 
   if (argc == 0)
     error (_("-data-write-register-values: Usage: -data-write-register-"
              "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
 
   format = (int) argv[0][0];
@@ skipping 25 matching lines @@
           regcache_cooked_write_signed (regcache, regnum, value);
         }
       else
         error (_("bad register number"));
     }
 }
 
 /* Evaluate the value of the argument.  The argument is an
    expression. If the expression contains spaces it needs to be
    included in double quotes.  */
+
 void
 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
 {
   struct expression *expr;
-  struct cleanup *old_chain = NULL;
+  struct cleanup *old_chain;
   struct value *val;
-  struct ui_stream *stb = NULL;
+  struct ui_file *stb;
   struct value_print_options opts;
   struct ui_out *uiout = current_uiout;
 
-  stb = ui_out_stream_new (uiout);
+  stb = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (stb);
 
   if (argc != 1)
-    {
-      ui_out_stream_delete (stb);
-      error (_("-data-evaluate-expression: "
-               "Usage: -data-evaluate-expression expression"));
-    }
+    error (_("-data-evaluate-expression: "
+             "Usage: -data-evaluate-expression expression"));
 
   expr = parse_expression (argv[0]);
 
-  old_chain = make_cleanup (free_current_contents, &expr);
+  make_cleanup (free_current_contents, &expr);
 
   val = evaluate_expression (expr);
 
   /* Print the result of the expression evaluation.  */
   get_user_print_options (&opts);
   opts.deref_ref = 0;
-  common_val_print (val, stb->stream, 0, &opts, current_language);
+  common_val_print (val, stb, 0, &opts, current_language);
 
   ui_out_field_stream (uiout, "value", stb);
-  ui_out_stream_delete (stb);
 
   do_cleanups (old_chain);
 }
 
-/* DATA-MEMORY-READ:
+/* This is the -data-read-memory command.
 
    ADDR: start address of data to be dumped.
    WORD-FORMAT: a char indicating format for the ``word''.  See 
    the ``x'' command.
    WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
    NR_ROW: Number of rows.
    NR_COL: The number of colums (words per row).
    ASCHAR: (OPTIONAL) Append an ascii character dump to each row.  Use
    ASCHAR for unprintable characters.
 
    Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
    displayes them.  Returns:
 
    {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
 
    Returns: 
-   The number of bytes read is SIZE*ROW*COL. */
+   The number of bytes read is SIZE*ROW*COL.  */
 
 void
 mi_cmd_data_read_memory (char *command, char **argv, int argc)
 {
   struct gdbarch *gdbarch = get_current_arch ();
   struct ui_out *uiout = current_uiout;
   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
   CORE_ADDR addr;
-  long total_bytes;
-  long nr_cols;
-  long nr_rows;
+  long total_bytes, nr_cols, nr_rows;
   char word_format;
   struct type *word_type;
   long word_size;
   char word_asize;
   char aschar;
   gdb_byte *mbuf;
   int nr_bytes;
   long offset = 0;
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
   enum opt
+  {
+    OFFSET_OPT
+  };
+  static const struct mi_opt opts[] =
     {
-      OFFSET_OPT
+      {"o", OFFSET_OPT, 1},
+      { 0, 0, 0 }
     };
-  static const struct mi_opt opts[] =
-  {
-    {"o", OFFSET_OPT, 1},
-    { 0, 0, 0 }
-  };
 
   while (1)
     {
       int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
-                           &optind, &optarg);
+                           &oind, &oarg);
 
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case OFFSET_OPT:
-          offset = atol (optarg);
+          offset = atol (oarg);
           break;
         }
     }
-  argv += optind;
-  argc -= optind;
+  argv += oind;
+  argc -= oind;
 
   if (argc < 5 || argc > 6)
     error (_("-data-read-memory: Usage: "
              "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
 
   /* Extract all the arguments. */
 
   /* Start address of the memory dump.  */
   addr = parse_and_eval_address (argv[0]) + offset;
   /* The format character to use when displaying a memory word.  See
-     the ``x'' command. */
+     the ``x'' command.  */
   word_format = argv[1][0];
   /* The size of the memory word.  */
   word_size = atol (argv[2]);
   switch (word_size)
     {
     case 1:
       word_type = builtin_type (gdbarch)->builtin_int8;
       word_asize = 'b';
       break;
     case 2:
@@ skipping 47 matching lines @@
   ui_out_field_int (uiout, "total-bytes", total_bytes);
   ui_out_field_core_addr (uiout, "next-row",
                           gdbarch, addr + word_size * nr_cols);
   ui_out_field_core_addr (uiout, "prev-row",
                           gdbarch, addr - word_size * nr_cols);
   ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
   ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
 
   /* Build the result as a two dimentional table.  */
   {
-    struct ui_stream *stream = ui_out_stream_new (uiout);
-    struct cleanup *cleanup_list_memory;
+    struct ui_file *stream;
+    struct cleanup *cleanup_stream;
     int row;
     int row_byte;
 
-    cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
+    stream = mem_fileopen ();
+    cleanup_stream = make_cleanup_ui_file_delete (stream);
+
+    make_cleanup_ui_out_list_begin_end (uiout, "memory");
     for (row = 0, row_byte = 0;
          row < nr_rows;
          row++, row_byte += nr_cols * word_size)
       {
         int col;
         int col_byte;
         struct cleanup *cleanup_tuple;
         struct cleanup *cleanup_list_data;
         struct value_print_options opts;
 
         cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
         ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
         /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
            row_byte); */
         cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
         get_formatted_print_options (&opts, word_format);
         for (col = 0, col_byte = row_byte;
              col < nr_cols;
              col++, col_byte += word_size)
           {
             if (col_byte + word_size > nr_bytes)
               {
                 ui_out_field_string (uiout, NULL, "N/A");
               }
             else
               {
-                ui_file_rewind (stream->stream);
+                ui_file_rewind (stream);
                 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
-                                        word_asize, stream->stream);
+                                        word_asize, stream);
                 ui_out_field_stream (uiout, NULL, stream);
               }
           }
         do_cleanups (cleanup_list_data);
         if (aschar)
           {
             int byte;
 
-            ui_file_rewind (stream->stream);
+            ui_file_rewind (stream);
             for (byte = row_byte;
                  byte < row_byte + word_size * nr_cols; byte++)
               {
                 if (byte >= nr_bytes)
-                  {
-                    fputc_unfiltered ('X', stream->stream);
-                  }
+                  fputc_unfiltered ('X', stream);
                 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
-                  {
-                    fputc_unfiltered (aschar, stream->stream);
-                  }
+                  fputc_unfiltered (aschar, stream);
                 else
-                  fputc_unfiltered (mbuf[byte], stream->stream);
+                  fputc_unfiltered (mbuf[byte], stream);
               }
             ui_out_field_stream (uiout, "ascii", stream);
           }
         do_cleanups (cleanup_tuple);
       }
-    ui_out_stream_delete (stream);
-    do_cleanups (cleanup_list_memory);
+    do_cleanups (cleanup_stream);
   }
   do_cleanups (cleanups);
 }
 
 void
 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
 {
   struct gdbarch *gdbarch = get_current_arch ();
   struct ui_out *uiout = current_uiout;
   struct cleanup *cleanups;
   CORE_ADDR addr;
   LONGEST length;
   memory_read_result_s *read_result;
   int ix;
   VEC(memory_read_result_s) *result;
   long offset = 0;
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
   enum opt
+  {
+    OFFSET_OPT
+  };
+  static const struct mi_opt opts[] =
     {
-      OFFSET_OPT
+      {"o", OFFSET_OPT, 1},
+      { 0, 0, 0 }
     };
-  static const struct mi_opt opts[] =
-  {
-    {"o", OFFSET_OPT, 1},
-    { 0, 0, 0 }
-  };
 
   while (1)
     {
       int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
-                           &optind, &optarg);
+                           &oind, &oarg);
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case OFFSET_OPT:
-          offset = atol (optarg);
+          offset = atol (oarg);
           break;
         }
     }
-  argv += optind;
-  argc -= optind;
+  argv += oind;
+  argc -= oind;
 
   if (argc != 2)
     error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
 
   addr = parse_and_eval_address (argv[0]) + offset;
   length = atol (argv[1]);
 
   result = read_memory_robust (current_target.beneath, addr, length);
 
   cleanups = make_cleanup (free_memory_read_result_vector, result);
@@ skipping 23 matching lines @@
         {
           sprintf (p, "%02x", read_result->data[i]);
         }
       ui_out_field_string (uiout, "contents", data);
       xfree (data);
       do_cleanups (t);
     }
   do_cleanups (cleanups);
 }
 
-
-/* DATA-MEMORY-WRITE:
+/* Implementation of the -data-write_memory command.
 
    COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
    offset from the beginning of the memory grid row where the cell to
    be written is.
    ADDR: start address of the row in the memory grid where the memory
    cell is, if OFFSET_COLUMN is specified.  Otherwise, the address of
    the location to write to.
    FORMAT: a char indicating format for the ``word''.  See 
    the ``x'' command.
    WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
    VALUE: value to be written into the memory address.
 
    Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
 
    Prints nothing.  */
+
 void
 mi_cmd_data_write_memory (char *command, char **argv, int argc)
 {
   struct gdbarch *gdbarch = get_current_arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR addr;
   char word_format;
   long word_size;
   /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
      enough when using a compiler other than GCC.  */
   LONGEST value;
   void *buffer;
   struct cleanup *old_chain;
   long offset = 0;
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
   enum opt
+  {
+    OFFSET_OPT
+  };
+  static const struct mi_opt opts[] =
     {
-      OFFSET_OPT
+      {"o", OFFSET_OPT, 1},
+      { 0, 0, 0 }
     };
-  static const struct mi_opt opts[] =
-  {
-    {"o", OFFSET_OPT, 1},
-    { 0, 0, 0 }
-  };
 
   while (1)
     {
       int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
-                           &optind, &optarg);
+                           &oind, &oarg);
 
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case OFFSET_OPT:
-          offset = atol (optarg);
+          offset = atol (oarg);
           break;
         }
     }
-  argv += optind;
-  argc -= optind;
+  argv += oind;
+  argc -= oind;
 
   if (argc != 4)
     error (_("-data-write-memory: Usage: "
              "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
 
   /* Extract all the arguments.  */
   /* Start address of the memory dump.  */
   addr = parse_and_eval_address (argv[0]);
   /* The format character to use when displaying a memory word.  See
      the ``x'' command.  */
   word_format = argv[1][0];
-  /* The size of the memory word. */
+  /* The size of the memory word.  */
   word_size = atol (argv[2]);
 
   /* Calculate the real address of the write destination.  */
   addr += (offset * word_size);
 
   /* Get the value as a number.  */
   value = parse_and_eval_address (argv[3]);
   /* Get the value into an array.  */
   buffer = xmalloc (word_size);
   old_chain = make_cleanup (xfree, buffer);
   store_signed_integer (buffer, word_size, byte_order, value);
   /* Write it down to memory.  */
   write_memory (addr, buffer, word_size);
   /* Free the buffer.  */
   do_cleanups (old_chain);
 }
 
-/* DATA-MEMORY-WRITE-RAW:
+/* Implementation of the -data-write-memory-bytes command.
 
    ADDR: start address
-   DATA: string of bytes to write at that address. */
+   DATA: string of bytes to write at that address.  */
+
 void
 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
 {
   CORE_ADDR addr;
   char *cdata;
   gdb_byte *data;
   int len, r, i;
   struct cleanup *back_to;
 
   if (argc != 2)
     error (_("Usage: ADDR DATA."));
 
   addr = parse_and_eval_address (argv[0]);
   cdata = argv[1];
   len = strlen (cdata)/2;
 
   data = xmalloc (len);
   back_to = make_cleanup (xfree, data);
 
   for (i = 0; i < len; ++i)
     {
       int x;
       sscanf (cdata + i * 2, "%02x", &x);
-      data[i] = (gdb_byte)x;
+      data[i] = (gdb_byte) x;
     }
 
   r = target_write_memory (addr, data, len);
   if (r != 0)
     error (_("Could not write memory"));
 
   do_cleanups (back_to);
 }
 
-
 void
 mi_cmd_enable_timings (char *command, char **argv, int argc)
 {
   if (argc == 0)
     do_timings = 1;
   else if (argc == 1)
     {
       if (strcmp (argv[0], "yes") == 0)
         do_timings = 1;
       else if (strcmp (argv[0], "no") == 0)
@@ skipping 64 matching lines @@
   struct inferior *inf;
 
   if (argc != 0)
     error (_("-add-inferior should be passed no arguments"));
 
   inf = add_inferior_with_spaces ();
 
   ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
 }
 
-/* Callback used to find the first inferior other than the
-   current one. */
+/* Callback used to find the first inferior other than the current
+   one.  */
    
 static int
 get_other_inferior (struct inferior *inf, void *arg)
 {
   if (inf == current_inferior ())
     return 0;
 
   return 1;
 }
 
@@ skipping 32 matching lines @@
       set_current_program_space (new_inferior->pspace);
     }
 
   delete_inferior_1 (inf, 1 /* silent */);
 }
 
 
 
 
 /* Execute a command within a safe environment.