Merge GDB 7.5.1

gdb/mi/mi-cmd-break.c

 /* MI Command Set - breakpoint and watchpoint commands.
    Copyright (C) 2000-2002, 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.
@@ skipping 25 matching lines @@
   };
 
 /* True if MI breakpoint observers have been registered.  */
 
 static int mi_breakpoint_observers_installed;
 
 /* Control whether breakpoint_notify may act.  */
 
 static int mi_can_breakpoint_notify;
 
-/* Output a single breakpoint, when allowed. */
+/* Output a single breakpoint, when allowed.  */
 
 static void
 breakpoint_notify (struct breakpoint *b)
 {
   if (mi_can_breakpoint_notify)
     gdb_breakpoint_query (current_uiout, b->number, NULL);
 }
 
 enum bp_type
   {
@@ skipping 34 matching lines @@
     {"i", IGNORE_COUNT_OPT, 1},
     {"p", THREAD_OPT, 1},
     {"f", PENDING_OPT, 0},
     {"d", DISABLE_OPT, 0},
     {"a", TRACEPOINT_OPT, 0},
     { 0, 0, 0 }
   };
 
   /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
      to denote the end of the option list. */
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
 
   while (1)
     {
       int opt = mi_getopt ("-break-insert", argc, argv,
-                           opts, &optind, &optarg);
+                           opts, &oind, &oarg);
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case TEMP_OPT:
           temp_p = 1;
           break;
         case HARDWARE_OPT:
           hardware = 1;
           break;
         case CONDITION_OPT:
-          condition = optarg;
+          condition = oarg;
           break;
         case IGNORE_COUNT_OPT:
-          ignore_count = atol (optarg);
+          ignore_count = atol (oarg);
           break;
         case THREAD_OPT:
-          thread = atol (optarg);
+          thread = atol (oarg);
           break;
         case PENDING_OPT:
           pending = 1;
           break;
         case DISABLE_OPT:
           enabled = 0;
           break;
         case TRACEPOINT_OPT:
           tracepoint = 1;
           break;
         }
     }
 
-  if (optind >= argc)
+  if (oind >= argc)
     error (_("-break-insert: Missing <location>"));
-  if (optind < argc - 1)
+  if (oind < argc - 1)
     error (_("-break-insert: Garbage following <location>"));
-  address = argv[optind];
+  address = argv[oind];
 
-  /* Now we have what we need, let's insert the breakpoint! */
+  /* Now we have what we need, let's insert the breakpoint!  */
   if (! mi_breakpoint_observers_installed)
     {
       observer_attach_breakpoint_created (breakpoint_notify);
       mi_breakpoint_observers_installed = 1;
     }
 
   back_to = make_cleanup_restore_integer (&mi_can_breakpoint_notify);
   mi_can_breakpoint_notify = 1;
 
   /* Note that to request a fast tracepoint, the client uses the
      "hardware" flag, although there's nothing of hardware related to
      fast tracepoints -- one can implement slow tracepoints with
      hardware breakpoints, but fast tracepoints are always software.
      "fast" is a misnomer, actually, "jump" would be more appropriate.
      A simulator or an emulator could conceivably implement fast
      regular non-jump based tracepoints.  */
   type_wanted = (tracepoint
                  ? (hardware ? bp_fast_tracepoint : bp_tracepoint)
                  : (hardware ? bp_hardware_breakpoint : bp_breakpoint));
 
   create_breakpoint (get_current_arch (), address, condition, thread,
+                     NULL,
                      0 /* condition and thread are valid.  */,
                      temp_p, type_wanted,
                      ignore_count,
                      pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE,
                      &bkpt_breakpoint_ops, 0, enabled, 0, 0);
   do_cleanups (back_to);
 
 }
 
 enum wp_type
@@ skipping 25 matching lines @@
   else
     {
       error (_("Could not find tracepoint %d"), n);
     }
 }
 
 /* Insert a watchpoint. The type of watchpoint is specified by the
    first argument: 
    -break-watch <expr> --> insert a regular wp.  
    -break-watch -r <expr> --> insert a read watchpoint.
-   -break-watch -a <expr> --> insert an access wp. */
+   -break-watch -a <expr> --> insert an access wp.  */
 
 void
 mi_cmd_break_watch (char *command, char **argv, int argc)
 {
   char *expr = NULL;
   enum wp_type type = REG_WP;
   enum opt
     {
       READ_OPT, ACCESS_OPT
     };
   static const struct mi_opt opts[] =
   {
     {"r", READ_OPT, 0},
     {"a", ACCESS_OPT, 0},
     { 0, 0, 0 }
   };
 
   /* Parse arguments. */
-  int optind = 0;
-  char *optarg;
+  int oind = 0;
+  char *oarg;
 
   while (1)
     {
       int opt = mi_getopt ("-break-watch", argc, argv,
-                           opts, &optind, &optarg);
+                           opts, &oind, &oarg);
 
       if (opt < 0)
         break;
       switch ((enum opt) opt)
         {
         case READ_OPT:
           type = READ_WP;
           break;
         case ACCESS_OPT:
           type = ACCESS_WP;
           break;
         }
     }
-  if (optind >= argc)
+  if (oind >= argc)
     error (_("-break-watch: Missing <expression>"));
-  if (optind < argc - 1)
+  if (oind < argc - 1)
     error (_("-break-watch: Garbage following <expression>"));
-  expr = argv[optind];
+  expr = argv[oind];
 
-  /* Now we have what we need, let's insert the watchpoint! */
+  /* Now we have what we need, let's insert the watchpoint!  */
   switch (type)
     {
     case REG_WP:
       watch_command_wrapper (expr, FROM_TTY, 0);
       break;
     case READ_WP:
       rwatch_command_wrapper (expr, FROM_TTY, 0);
       break;
     case ACCESS_WP:
       awatch_command_wrapper (expr, FROM_TTY, 0);
@@ skipping 50 matching lines @@
 
   if (is_tracepoint (b))
     break_command = read_command_lines_1 (mi_read_next_line, 1,
                                           check_tracepoint_command, b);
   else
     break_command = read_command_lines_1 (mi_read_next_line, 1, 0, 0);
 
   breakpoint_set_commands (b, break_command);
 }