projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix crash when exiting TUI with gdb -tui
[deliverable/binutils-gdb.git] / gdb / annotate.c
diff --git a/gdb/annotate.c b/gdb/annotate.c
index 1c235a568e526cf75dd29f1177eca24606b1be60..0a4e2f27cac0cb8579cc263f034fd51fe79bd783 100644 (file)
--- a/gdb/annotate.c
+++ b/gdb/annotate.c
@@ -1,11 +1,11 @@
 /* Annotation routines for GDB.
 /* Annotation routines for GDB.
-   Copyright 1986, 89, 90, 91, 92, 95, 98, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.
 
    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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -14,9 +14,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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 "annotate.h"
 
 #include "defs.h"
 #include "annotate.h"
@@ -24,561 +22,613 @@
 #include "target.h"
 #include "gdbtypes.h"
 #include "breakpoint.h"
 #include "target.h"
 #include "gdbtypes.h"
 #include "breakpoint.h"
+#include "observable.h"
+#include "inferior.h"
+#include "infrun.h"
+#include "top.h"
+#include "source.h"
+#include "objfiles.h"
+#include "source-cache.h"
 \f
 
 \f
 
-/* Prototypes for local functions. */
+/* Prototypes for local functions.  */
 
 
-extern void _initialize_annotate PARAMS ((void));
+static void print_value_flags (struct type *);
 
 
-static void print_value_flags PARAMS ((struct type *));
+static void breakpoint_changed (struct breakpoint *b);
 
 
-static void breakpoint_changed PARAMS ((struct breakpoint *));
 
 
-void (*annotate_starting_hook) PARAMS ((void));
-void (*annotate_stopped_hook) PARAMS ((void));
-void (*annotate_signalled_hook) PARAMS ((void));
-void (*annotate_signal_hook) PARAMS ((void));
-void (*annotate_exited_hook) PARAMS ((void));
+void (*deprecated_annotate_signalled_hook) (void);
+void (*deprecated_annotate_signal_hook) (void);
+
+/* Booleans indicating whether we've emitted certain notifications.
+   Used to suppress useless repeated notifications until the next time
+   we're ready to accept more commands.  Reset whenever a prompt is
+   displayed.  */
+static int frames_invalid_emitted;
+static int breakpoints_invalid_emitted;
 
 static void
 
 static void
-print_value_flags (t)
-     struct type *t;
+print_value_flags (struct type *t)
 {
   if (can_dereference (t))
 {
   if (can_dereference (t))
-    printf_filtered ("*");
+    printf_filtered (("*"));
   else
   else
-    printf_filtered ("-");
+    printf_filtered (("-"));
 }
 }
-\f
-void
-breakpoints_changed ()
+
+static void
+annotate_breakpoints_invalid (void)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level == 2
+      && (!breakpoints_invalid_emitted
+         || current_ui->prompt_state != PROMPT_BLOCKED))
     {
     {
-      target_terminal_ours ();
-      printf_unfiltered ("\n\032\032breakpoints-invalid\n");
+      target_terminal::scoped_restore_terminal_state term_state;
+      target_terminal::ours_for_output ();
+
+      printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
+      breakpoints_invalid_emitted = 1;
     }
 }
 
 void
     }
 }
 
 void
-annotate_breakpoint (num)
-     int num;
+annotate_breakpoint (int num)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032breakpoint %d\n", num);
+    printf_filtered (("\n\032\032breakpoint %d\n"), num);
 }
 
 void
 }
 
 void
-annotate_catchpoint (num)
-     int num;
+annotate_catchpoint (int num)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032catchpoint %d\n", num);
+    printf_filtered (("\n\032\032catchpoint %d\n"), num);
 }
 
 void
 }
 
 void
-annotate_watchpoint (num)
-     int num;
+annotate_watchpoint (int num)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032watchpoint %d\n", num);
+    printf_filtered (("\n\032\032watchpoint %d\n"), num);
 }
 
 void
 }
 
 void
-annotate_starting ()
+annotate_starting (void)
 {
 {
-
-  if (annotate_starting_hook)
-    annotate_starting_hook ();
-  else
-    {
-      if (annotation_level > 1)
-       {
-         printf_filtered ("\n\032\032starting\n");
-       }
-    }
+  if (annotation_level > 1)
+    printf_filtered (("\n\032\032starting\n"));
 }
 
 void
 }
 
 void
-annotate_stopped ()
+annotate_stopped (void)
 {
 {
-  if (annotate_stopped_hook)
-    annotate_stopped_hook ();
-  else
-    {
-      if (annotation_level > 1)
-       printf_filtered ("\n\032\032stopped\n");
-    }
+  if (annotation_level > 1)
+    printf_filtered (("\n\032\032stopped\n"));
 }
 
 void
 }
 
 void
-annotate_exited (exitstatus)
-     int exitstatus;
+annotate_exited (int exitstatus)
 {
 {
-  if (annotate_exited_hook)
-    annotate_exited_hook ();
-  else
-    {
-      if (annotation_level > 1)
-       printf_filtered ("\n\032\032exited %d\n", exitstatus);
-    }
+  if (annotation_level > 1)
+    printf_filtered (("\n\032\032exited %d\n"), exitstatus);
 }
 
 void
 }
 
 void
-annotate_signalled ()
+annotate_signalled (void)
 {
 {
-  if (annotate_signalled_hook)
-    annotate_signalled_hook ();
+  if (deprecated_annotate_signalled_hook)
+    deprecated_annotate_signalled_hook ();
 
   if (annotation_level > 1)
 
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032signalled\n");
+    printf_filtered (("\n\032\032signalled\n"));
 }
 
 void
 }
 
 void
-annotate_signal_name ()
+annotate_signal_name (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal-name\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032signal-name\n"));
 }
 
 void
 }
 
 void
-annotate_signal_name_end ()
+annotate_signal_name_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal-name-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032signal-name-end\n"));
 }
 
 void
 }
 
 void
-annotate_signal_string ()
+annotate_signal_string (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal-string\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032signal-string\n"));
 }
 
 void
 }
 
 void
-annotate_signal_string_end ()
+annotate_signal_string_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal-string-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032signal-string-end\n"));
 }
 
 void
 }
 
 void
-annotate_signal ()
+annotate_signal (void)
 {
 {
-  if (annotate_signal_hook)
-    annotate_signal_hook ();
+  if (deprecated_annotate_signal_hook)
+    deprecated_annotate_signal_hook ();
 
   if (annotation_level > 1)
 
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal\n");
+    printf_filtered (("\n\032\032signal\n"));
 }
 \f
 void
 }
 \f
 void
-annotate_breakpoints_headers ()
+annotate_breakpoints_headers (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032breakpoints-headers\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032breakpoints-headers\n"));
 }
 
 void
 }
 
 void
-annotate_field (num)
-     int num;
+annotate_field (int num)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032field %d\n", num);
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032field %d\n"), num);
 }
 
 void
 }
 
 void
-annotate_breakpoints_table ()
+annotate_breakpoints_table (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032breakpoints-table\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032breakpoints-table\n"));
 }
 
 void
 }
 
 void
-annotate_record ()
+annotate_record (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032record\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032record\n"));
 }
 
 void
 }
 
 void
-annotate_breakpoints_table_end ()
+annotate_breakpoints_table_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032breakpoints-table-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032breakpoints-table-end\n"));
 }
 
 void
 }
 
 void
-annotate_frames_invalid ()
+annotate_frames_invalid (void)
+{
+  if (annotation_level == 2
+      && (!frames_invalid_emitted
+         || current_ui->prompt_state != PROMPT_BLOCKED))
+    {
+      target_terminal::scoped_restore_terminal_state term_state;
+      target_terminal::ours_for_output ();
+
+      printf_unfiltered (("\n\032\032frames-invalid\n"));
+      frames_invalid_emitted = 1;
+    }
+}
+
+void
+annotate_new_thread (void)
 {
   if (annotation_level > 1)
     {
 {
   if (annotation_level > 1)
     {
-      target_terminal_ours ();
-      printf_unfiltered ("\n\032\032frames-invalid\n");
+      printf_unfiltered (("\n\032\032new-thread\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_field_begin (type)
-     struct type *type;
+annotate_thread_changed (void)
+{
+  if (annotation_level > 1)
+    {
+      printf_unfiltered (("\n\032\032thread-changed\n"));
+    }
+}
+
+/* Emit notification on thread exit.  */
+
+static void
+annotate_thread_exited (struct thread_info *t, int silent)
 {
   if (annotation_level > 1)
     {
 {
   if (annotation_level > 1)
     {
-      printf_filtered ("\n\032\032field-begin ");
+      printf_filtered(("\n\032\032thread-exited,"
+                       "id=\"%d\",group-id=\"i%d\"\n"),
+                      t->global_num, t->inf->num);
+    }
+}
+
+void
+annotate_field_begin (struct type *type)
+{
+  if (annotation_level == 2)
+    {
+      printf_filtered (("\n\032\032field-begin "));
       print_value_flags (type);
       print_value_flags (type);
-      printf_filtered ("\n");
+      printf_filtered (("\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_field_name_end ()
+annotate_field_name_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032field-name-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032field-name-end\n"));
 }
 
 void
 }
 
 void
-annotate_field_value ()
+annotate_field_value (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032field-value\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032field-value\n"));
 }
 
 void
 }
 
 void
-annotate_field_end ()
+annotate_field_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032field-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032field-end\n"));
 }
 \f
 void
 }
 \f
 void
-annotate_quit ()
+annotate_quit (void)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032quit\n");
+    printf_filtered (("\n\032\032quit\n"));
 }
 
 void
 }
 
 void
-annotate_error ()
+annotate_error (void)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032error\n");
+    printf_filtered (("\n\032\032error\n"));
 }
 
 void
 }
 
 void
-annotate_error_begin ()
+annotate_error_begin (void)
 {
   if (annotation_level > 1)
     fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
 }
 
 void
 {
   if (annotation_level > 1)
     fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
 }
 
 void
-annotate_value_history_begin (histindex, type)
-     int histindex;
-     struct type *type;
+annotate_value_history_begin (int histindex, struct type *type)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level == 2)
     {
     {
-      printf_filtered ("\n\032\032value-history-begin %d ", histindex);
+      printf_filtered (("\n\032\032value-history-begin %d "), histindex);
       print_value_flags (type);
       print_value_flags (type);
-      printf_filtered ("\n");
+      printf_filtered (("\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_value_begin (type)
-     struct type *type;
+annotate_value_begin (struct type *type)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level == 2)
     {
     {
-      printf_filtered ("\n\032\032value-begin ");
+      printf_filtered (("\n\032\032value-begin "));
       print_value_flags (type);
       print_value_flags (type);
-      printf_filtered ("\n");
+      printf_filtered (("\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_value_history_value ()
+annotate_value_history_value (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032value-history-value\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032value-history-value\n"));
 }
 
 void
 }
 
 void
-annotate_value_history_end ()
+annotate_value_history_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032value-history-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032value-history-end\n"));
 }
 
 void
 }
 
 void
-annotate_value_end ()
+annotate_value_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032value-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032value-end\n"));
 }
 
 void
 }
 
 void
-annotate_display_begin ()
+annotate_display_begin (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-begin\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-begin\n"));
 }
 
 void
 }
 
 void
-annotate_display_number_end ()
+annotate_display_number_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-number-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-number-end\n"));
 }
 
 void
 }
 
 void
-annotate_display_format ()
+annotate_display_format (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-format\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-format\n"));
 }
 
 void
 }
 
 void
-annotate_display_expression ()
+annotate_display_expression (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-expression\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-expression\n"));
 }
 
 void
 }
 
 void
-annotate_display_expression_end ()
+annotate_display_expression_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-expression-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-expression-end\n"));
 }
 
 void
 }
 
 void
-annotate_display_value ()
+annotate_display_value (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-value\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-value\n"));
 }
 
 void
 }
 
 void
-annotate_display_end ()
+annotate_display_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032display-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032display-end\n"));
 }
 
 void
 }
 
 void
-annotate_arg_begin ()
+annotate_arg_begin (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032arg-begin\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032arg-begin\n"));
 }
 
 void
 }
 
 void
-annotate_arg_name_end ()
+annotate_arg_name_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032arg-name-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032arg-name-end\n"));
 }
 
 void
 }
 
 void
-annotate_arg_value (type)
-     struct type *type;
+annotate_arg_value (struct type *type)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level == 2)
     {
     {
-      printf_filtered ("\n\032\032arg-value ");
+      printf_filtered (("\n\032\032arg-value "));
       print_value_flags (type);
       print_value_flags (type);
-      printf_filtered ("\n");
+      printf_filtered (("\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_arg_end ()
+annotate_arg_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032arg-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032arg-end\n"));
 }
 
 }
 
-void
-annotate_source (filename, line, character, mid, pc)
-     char *filename;
-     int line;
-     int character;
-     int mid;
-     CORE_ADDR pc;
+static void
+annotate_source (const char *filename, int line, int character, int mid,
+                struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032source ");
+    printf_filtered (("\n\032\032source "));
   else
   else
-    printf_filtered ("\032\032");
+    printf_filtered (("\032\032"));
 
 
-  printf_filtered ("%s:%d:%d:%s:0x", filename,
-                  line, character,
-                  mid ? "middle" : "beg");
-  print_address_numeric (pc, 0, gdb_stdout);
-  printf_filtered ("\n");
+  printf_filtered (("%s:%d:%d:%s:%s\n"), filename, line, character,
+                  mid ? "middle" : "beg", paddress (gdbarch, pc));
 }
 
 }
 
-void
-annotate_frame_begin (level, pc)
-     int level;
-     CORE_ADDR pc;
+/* See annotate.h.  */
+
+bool
+annotate_source_line (struct symtab *s, int line, int mid_statement,
+                     CORE_ADDR pc)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level > 0)
     {
     {
-      printf_filtered ("\n\032\032frame-begin %d 0x", level);
-      print_address_numeric (pc, 0, gdb_stdout);
-      printf_filtered ("\n");
+      const std::vector<off_t> *offsets;
+      if (!g_source_cache.get_line_charpos (s, &offsets))
+       return false;
+      if (line > offsets->size ())
+       return false;
+
+      annotate_source (s->fullname, line, (int) (*offsets)[line - 1],
+                      mid_statement, SYMTAB_OBJFILE (s)->arch (),
+                      pc);
+
+      /* Update the current symtab and line.  */
+      symtab_and_line sal;
+      sal.pspace = SYMTAB_PSPACE (s);
+      sal.symtab = s;
+      sal.line = line;
+      set_current_source_symtab_and_line (sal);
+
+      return true;
     }
     }
+
+  return false;
 }
 
 }
 
+
 void
 void
-annotate_function_call ()
+annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   if (annotation_level > 1)
 {
   if (annotation_level > 1)
-    printf_filtered ("\n\032\032function-call\n");
+    printf_filtered (("\n\032\032frame-begin %d %s\n"),
+                    level, paddress (gdbarch, pc));
 }
 
 void
 }
 
 void
-annotate_signal_handler_caller ()
+annotate_function_call (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032signal-handler-caller\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032function-call\n"));
 }
 
 void
 }
 
 void
-annotate_frame_address ()
+annotate_signal_handler_caller (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-address\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032signal-handler-caller\n"));
 }
 
 void
 }
 
 void
-annotate_frame_address_end ()
+annotate_frame_address (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-address-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-address\n"));
 }
 
 void
 }
 
 void
-annotate_frame_function_name ()
+annotate_frame_address_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-function-name\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-address-end\n"));
 }
 
 void
 }
 
 void
-annotate_frame_args ()
+annotate_frame_function_name (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-args\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-function-name\n"));
 }
 
 void
 }
 
 void
-annotate_frame_source_begin ()
+annotate_frame_args (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-source-begin\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-args\n"));
 }
 
 void
 }
 
 void
-annotate_frame_source_file ()
+annotate_frame_source_begin (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-source-file\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-source-begin\n"));
 }
 
 void
 }
 
 void
-annotate_frame_source_file_end ()
+annotate_frame_source_file (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-source-file-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-source-file\n"));
 }
 
 void
 }
 
 void
-annotate_frame_source_line ()
+annotate_frame_source_file_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-source-line\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-source-file-end\n"));
 }
 
 void
 }
 
 void
-annotate_frame_source_end ()
+annotate_frame_source_line (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-source-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-source-line\n"));
 }
 
 void
 }
 
 void
-annotate_frame_where ()
+annotate_frame_source_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-where\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-source-end\n"));
 }
 
 void
 }
 
 void
-annotate_frame_end ()
+annotate_frame_where (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032frame-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-where\n"));
+}
+
+void
+annotate_frame_end (void)
+{
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032frame-end\n"));
 }
 \f
 void
 }
 \f
 void
-annotate_array_section_begin (index, elttype)
-     int index;
-     struct type *elttype;
+annotate_array_section_begin (int idx, struct type *elttype)
 {
 {
-  if (annotation_level > 1)
+  if (annotation_level == 2)
     {
     {
-      printf_filtered ("\n\032\032array-section-begin %d ", index);
+      printf_filtered (("\n\032\032array-section-begin %d "), idx);
       print_value_flags (elttype);
       print_value_flags (elttype);
-      printf_filtered ("\n");
+      printf_filtered (("\n"));
     }
 }
 
 void
     }
 }
 
 void
-annotate_elt_rep (repcount)
-     unsigned int repcount;
+annotate_elt_rep (unsigned int repcount)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032elt-rep %u\n", repcount);
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
 }
 
 void
 }
 
 void
-annotate_elt_rep_end ()
+annotate_elt_rep_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032elt-rep-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032elt-rep-end\n"));
 }
 
 void
 }
 
 void
-annotate_elt ()
+annotate_elt (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032elt\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032elt\n"));
 }
 
 void
 }
 
 void
-annotate_array_section_end ()
+annotate_array_section_end (void)
 {
 {
-  if (annotation_level > 1)
-    printf_filtered ("\n\032\032array-section-end\n");
+  if (annotation_level == 2)
+    printf_filtered (("\n\032\032array-section-end\n"));
+}
+
+/* Called when GDB is about to display the prompt.  Used to reset
+   annotation suppression whenever we're ready to accept new
+   frontend/user commands.  */
+
+void
+annotate_display_prompt (void)
+{
+  frames_invalid_emitted = 0;
+  breakpoints_invalid_emitted = 0;
 }
 
 static void
 }
 
 static void
-breakpoint_changed (b)
-     struct breakpoint *b;
+breakpoint_changed (struct breakpoint *b)
 {
 {
-  breakpoints_changed ();
+  if (b->number <= 0)
+    return;
+
+  annotate_breakpoints_invalid ();
 }
 
 }
 
+void _initialize_annotate ();
 void
 _initialize_annotate ()
 {
 void
 _initialize_annotate ()
 {
-  if (annotation_level > 1)
-    {
-      delete_breakpoint_hook = breakpoint_changed;
-      modify_breakpoint_hook = breakpoint_changed;
-    }
+  gdb::observers::breakpoint_created.attach (breakpoint_changed);
+  gdb::observers::breakpoint_deleted.attach (breakpoint_changed);
+  gdb::observers::breakpoint_modified.attach (breakpoint_changed);
+  gdb::observers::thread_exit.attach (annotate_thread_exited);
 }
 }
GDB Binutils - Deliverables
This page took 0.046473 seconds and 4 git commands to generate.