gdb/annotate.c

   1 /* Annotation routines for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999,
   3    2000 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "annotate.h"
  24 #include "value.h"
  25 #include "target.h"
  26 #include "gdbtypes.h"
  27 #include "breakpoint.h"
  28 \f
  29
  30 /* Prototypes for local functions. */
  31
  32 extern void _initialize_annotate (void);
  33
  34 static void print_value_flags (struct type *);
  35
  36 static void breakpoint_changed (struct breakpoint *);
  37
  38 void (*deprecated_annotate_starting_hook) (void);
  39 void (*deprecated_annotate_stopped_hook) (void);
  40 void (*deprecated_annotate_signalled_hook) (void);
  41 void (*deprecated_annotate_signal_hook) (void);
  42 void (*deprecated_annotate_exited_hook) (void);
  43
  44 static int ignore_count_changed = 0;
  45
  46 static void
  47 print_value_flags (struct type *t)
  48 {
  49   if (can_dereference (t))
  50     printf_filtered (("*"));
  51   else
  52     printf_filtered (("-"));
  53 }
  54 \f
  55 void
  56 breakpoints_changed (void)
  57 {
  58   if (annotation_level == 2)
  59     {
  60       target_terminal_ours ();
  61       printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
  62       if (ignore_count_changed)
  63         ignore_count_changed = 0;       /* Avoid multiple break annotations. */
  64     }
  65 }
  66
  67 /* The GUI needs to be informed of ignore_count changes, but we don't
  68    want to provide successive multiple breakpoints-invalid messages
  69    that are all caused by the fact that the ignore count is changing
  70    (which could keep the GUI very busy).  One is enough, after the
  71    target actually "stops". */
  72
  73 void
  74 annotate_ignore_count_change (void)
  75 {
  76   if (annotation_level > 1)
  77     ignore_count_changed = 1;
  78 }
  79
  80 void
  81 annotate_breakpoint (int num)
  82 {
  83   if (annotation_level > 1)
  84     printf_filtered (("\n\032\032breakpoint %d\n"), num);
  85 }
  86
  87 void
  88 annotate_catchpoint (int num)
  89 {
  90   if (annotation_level > 1)
  91     printf_filtered (("\n\032\032catchpoint %d\n"), num);
  92 }
  93
  94 void
  95 annotate_watchpoint (int num)
  96 {
  97   if (annotation_level > 1)
  98     printf_filtered (("\n\032\032watchpoint %d\n"), num);
  99 }
 100
 101 void
 102 annotate_starting (void)
 103 {
 104
 105   if (deprecated_annotate_starting_hook)
 106     deprecated_annotate_starting_hook ();
 107   else
 108     {
 109       if (annotation_level > 1)
 110         {
 111           printf_filtered (("\n\032\032starting\n"));
 112         }
 113     }
 114 }
 115
 116 void
 117 annotate_stopped (void)
 118 {
 119   if (deprecated_annotate_stopped_hook)
 120     deprecated_annotate_stopped_hook ();
 121   else
 122     {
 123       if (annotation_level > 1)
 124         printf_filtered (("\n\032\032stopped\n"));
 125     }
 126   if (annotation_level > 1 && ignore_count_changed)
 127     {
 128       ignore_count_changed = 0;
 129       breakpoints_changed ();
 130     }
 131 }
 132
 133 void
 134 annotate_exited (int exitstatus)
 135 {
 136   if (deprecated_annotate_exited_hook)
 137     deprecated_annotate_exited_hook ();
 138   else
 139     {
 140       if (annotation_level > 1)
 141         printf_filtered (("\n\032\032exited %d\n"), exitstatus);
 142     }
 143 }
 144
 145 void
 146 annotate_signalled (void)
 147 {
 148   if (deprecated_annotate_signalled_hook)
 149     deprecated_annotate_signalled_hook ();
 150
 151   if (annotation_level > 1)
 152     printf_filtered (("\n\032\032signalled\n"));
 153 }
 154
 155 void
 156 annotate_signal_name (void)
 157 {
 158   if (annotation_level == 2)
 159     printf_filtered (("\n\032\032signal-name\n"));
 160 }
 161
 162 void
 163 annotate_signal_name_end (void)
 164 {
 165   if (annotation_level == 2)
 166     printf_filtered (("\n\032\032signal-name-end\n"));
 167 }
 168
 169 void
 170 annotate_signal_string (void)
 171 {
 172   if (annotation_level == 2)
 173     printf_filtered (("\n\032\032signal-string\n"));
 174 }
 175
 176 void
 177 annotate_signal_string_end (void)
 178 {
 179   if (annotation_level == 2)
 180     printf_filtered (("\n\032\032signal-string-end\n"));
 181 }
 182
 183 void
 184 annotate_signal (void)
 185 {
 186   if (deprecated_annotate_signal_hook)
 187     deprecated_annotate_signal_hook ();
 188
 189   if (annotation_level > 1)
 190     printf_filtered (("\n\032\032signal\n"));
 191 }
 192 \f
 193 void
 194 annotate_breakpoints_headers (void)
 195 {
 196   if (annotation_level == 2)
 197     printf_filtered (("\n\032\032breakpoints-headers\n"));
 198 }
 199
 200 void
 201 annotate_field (int num)
 202 {
 203   if (annotation_level == 2)
 204     printf_filtered (("\n\032\032field %d\n"), num);
 205 }
 206
 207 void
 208 annotate_breakpoints_table (void)
 209 {
 210   if (annotation_level == 2)
 211     printf_filtered (("\n\032\032breakpoints-table\n"));
 212 }
 213
 214 void
 215 annotate_record (void)
 216 {
 217   if (annotation_level == 2)
 218     printf_filtered (("\n\032\032record\n"));
 219 }
 220
 221 void
 222 annotate_breakpoints_table_end (void)
 223 {
 224   if (annotation_level == 2)
 225     printf_filtered (("\n\032\032breakpoints-table-end\n"));
 226 }
 227
 228 void
 229 annotate_frames_invalid (void)
 230 {
 231   if (annotation_level == 2)
 232     {
 233       target_terminal_ours ();
 234       printf_unfiltered (("\n\032\032frames-invalid\n"));
 235     }
 236 }
 237
 238 void
 239 annotate_field_begin (struct type *type)
 240 {
 241   if (annotation_level == 2)
 242     {
 243       printf_filtered (("\n\032\032field-begin "));
 244       print_value_flags (type);
 245       printf_filtered (("\n"));
 246     }
 247 }
 248
 249 void
 250 annotate_field_name_end (void)
 251 {
 252   if (annotation_level == 2)
 253     printf_filtered (("\n\032\032field-name-end\n"));
 254 }
 255
 256 void
 257 annotate_field_value (void)
 258 {
 259   if (annotation_level == 2)
 260     printf_filtered (("\n\032\032field-value\n"));
 261 }
 262
 263 void
 264 annotate_field_end (void)
 265 {
 266   if (annotation_level == 2)
 267     printf_filtered (("\n\032\032field-end\n"));
 268 }
 269 \f
 270 void
 271 annotate_quit (void)
 272 {
 273   if (annotation_level > 1)
 274     printf_filtered (("\n\032\032quit\n"));
 275 }
 276
 277 void
 278 annotate_error (void)
 279 {
 280   if (annotation_level > 1)
 281     printf_filtered (("\n\032\032error\n"));
 282 }
 283
 284 void
 285 annotate_error_begin (void)
 286 {
 287   if (annotation_level > 1)
 288     fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
 289 }
 290
 291 void
 292 annotate_value_history_begin (int histindex, struct type *type)
 293 {
 294   if (annotation_level == 2)
 295     {
 296       printf_filtered (("\n\032\032value-history-begin %d "), histindex);
 297       print_value_flags (type);
 298       printf_filtered (("\n"));
 299     }
 300 }
 301
 302 void
 303 annotate_value_begin (struct type *type)
 304 {
 305   if (annotation_level == 2)
 306     {
 307       printf_filtered (("\n\032\032value-begin "));
 308       print_value_flags (type);
 309       printf_filtered (("\n"));
 310     }
 311 }
 312
 313 void
 314 annotate_value_history_value (void)
 315 {
 316   if (annotation_level == 2)
 317     printf_filtered (("\n\032\032value-history-value\n"));
 318 }
 319
 320 void
 321 annotate_value_history_end (void)
 322 {
 323   if (annotation_level == 2)
 324     printf_filtered (("\n\032\032value-history-end\n"));
 325 }
 326
 327 void
 328 annotate_value_end (void)
 329 {
 330   if (annotation_level == 2)
 331     printf_filtered (("\n\032\032value-end\n"));
 332 }
 333
 334 void
 335 annotate_display_begin (void)
 336 {
 337   if (annotation_level == 2)
 338     printf_filtered (("\n\032\032display-begin\n"));
 339 }
 340
 341 void
 342 annotate_display_number_end (void)
 343 {
 344   if (annotation_level == 2)
 345     printf_filtered (("\n\032\032display-number-end\n"));
 346 }
 347
 348 void
 349 annotate_display_format (void)
 350 {
 351   if (annotation_level == 2)
 352     printf_filtered (("\n\032\032display-format\n"));
 353 }
 354
 355 void
 356 annotate_display_expression (void)
 357 {
 358   if (annotation_level == 2)
 359     printf_filtered (("\n\032\032display-expression\n"));
 360 }
 361
 362 void
 363 annotate_display_expression_end (void)
 364 {
 365   if (annotation_level == 2)
 366     printf_filtered (("\n\032\032display-expression-end\n"));
 367 }
 368
 369 void
 370 annotate_display_value (void)
 371 {
 372   if (annotation_level == 2)
 373     printf_filtered (("\n\032\032display-value\n"));
 374 }
 375
 376 void
 377 annotate_display_end (void)
 378 {
 379   if (annotation_level == 2)
 380     printf_filtered (("\n\032\032display-end\n"));
 381 }
 382
 383 void
 384 annotate_arg_begin (void)
 385 {
 386   if (annotation_level == 2)
 387     printf_filtered (("\n\032\032arg-begin\n"));
 388 }
 389
 390 void
 391 annotate_arg_name_end (void)
 392 {
 393   if (annotation_level == 2)
 394     printf_filtered (("\n\032\032arg-name-end\n"));
 395 }
 396
 397 void
 398 annotate_arg_value (struct type *type)
 399 {
 400   if (annotation_level == 2)
 401     {
 402       printf_filtered (("\n\032\032arg-value "));
 403       print_value_flags (type);
 404       printf_filtered (("\n"));
 405     }
 406 }
 407
 408 void
 409 annotate_arg_end (void)
 410 {
 411   if (annotation_level == 2)
 412     printf_filtered (("\n\032\032arg-end\n"));
 413 }
 414
 415 void
 416 annotate_source (char *filename, int line, int character, int mid, CORE_ADDR pc)
 417 {
 418   if (annotation_level > 1)
 419     printf_filtered (("\n\032\032source "));
 420   else
 421     printf_filtered (("\032\032"));
 422
 423   printf_filtered (("%s:%d:%d:%s:0x"), filename,
 424                    line, character,
 425                    mid ? "middle" : "beg");
 426   deprecated_print_address_numeric (pc, 0, gdb_stdout);
 427   printf_filtered (("\n"));
 428 }
 429
 430 void
 431 annotate_frame_begin (int level, CORE_ADDR pc)
 432 {
 433   if (annotation_level > 1)
 434     {
 435       printf_filtered (("\n\032\032frame-begin %d 0x"), level);
 436       deprecated_print_address_numeric (pc, 0, gdb_stdout);
 437       printf_filtered (("\n"));
 438     }
 439 }
 440
 441 void
 442 annotate_function_call (void)
 443 {
 444   if (annotation_level == 2)
 445     printf_filtered (("\n\032\032function-call\n"));
 446 }
 447
 448 void
 449 annotate_signal_handler_caller (void)
 450 {
 451   if (annotation_level == 2)
 452     printf_filtered (("\n\032\032signal-handler-caller\n"));
 453 }
 454
 455 void
 456 annotate_frame_address (void)
 457 {
 458   if (annotation_level == 2)
 459     printf_filtered (("\n\032\032frame-address\n"));
 460 }
 461
 462 void
 463 annotate_frame_address_end (void)
 464 {
 465   if (annotation_level == 2)
 466     printf_filtered (("\n\032\032frame-address-end\n"));
 467 }
 468
 469 void
 470 annotate_frame_function_name (void)
 471 {
 472   if (annotation_level == 2)
 473     printf_filtered (("\n\032\032frame-function-name\n"));
 474 }
 475
 476 void
 477 annotate_frame_args (void)
 478 {
 479   if (annotation_level == 2)
 480     printf_filtered (("\n\032\032frame-args\n"));
 481 }
 482
 483 void
 484 annotate_frame_source_begin (void)
 485 {
 486   if (annotation_level == 2)
 487     printf_filtered (("\n\032\032frame-source-begin\n"));
 488 }
 489
 490 void
 491 annotate_frame_source_file (void)
 492 {
 493   if (annotation_level == 2)
 494     printf_filtered (("\n\032\032frame-source-file\n"));
 495 }
 496
 497 void
 498 annotate_frame_source_file_end (void)
 499 {
 500   if (annotation_level == 2)
 501     printf_filtered (("\n\032\032frame-source-file-end\n"));
 502 }
 503
 504 void
 505 annotate_frame_source_line (void)
 506 {
 507   if (annotation_level == 2)
 508     printf_filtered (("\n\032\032frame-source-line\n"));
 509 }
 510
 511 void
 512 annotate_frame_source_end (void)
 513 {
 514   if (annotation_level == 2)
 515     printf_filtered (("\n\032\032frame-source-end\n"));
 516 }
 517
 518 void
 519 annotate_frame_where (void)
 520 {
 521   if (annotation_level == 2)
 522     printf_filtered (("\n\032\032frame-where\n"));
 523 }
 524
 525 void
 526 annotate_frame_end (void)
 527 {
 528   if (annotation_level == 2)
 529     printf_filtered (("\n\032\032frame-end\n"));
 530 }
 531 \f
 532 void
 533 annotate_array_section_begin (int index, struct type *elttype)
 534 {
 535   if (annotation_level == 2)
 536     {
 537       printf_filtered (("\n\032\032array-section-begin %d "), index);
 538       print_value_flags (elttype);
 539       printf_filtered (("\n"));
 540     }
 541 }
 542
 543 void
 544 annotate_elt_rep (unsigned int repcount)
 545 {
 546   if (annotation_level == 2)
 547     printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
 548 }
 549
 550 void
 551 annotate_elt_rep_end (void)
 552 {
 553   if (annotation_level == 2)
 554     printf_filtered (("\n\032\032elt-rep-end\n"));
 555 }
 556
 557 void
 558 annotate_elt (void)
 559 {
 560   if (annotation_level == 2)
 561     printf_filtered (("\n\032\032elt\n"));
 562 }
 563
 564 void
 565 annotate_array_section_end (void)
 566 {
 567   if (annotation_level == 2)
 568     printf_filtered (("\n\032\032array-section-end\n"));
 569 }
 570
 571 static void
 572 breakpoint_changed (struct breakpoint *b)
 573 {
 574   breakpoints_changed ();
 575 }
 576
 577 void
 578 _initialize_annotate (void)
 579 {
 580   if (annotation_level == 2)
 581     {
 582       deprecated_delete_breakpoint_hook = breakpoint_changed;
 583       deprecated_modify_breakpoint_hook = breakpoint_changed;
 584     }
 585 }