OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [annotate.c] - Blame information for rev 578

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom 
/* Annotation routines for GDB.
2 
   Copyright 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., 59 Temple Place - Suite 330,
20 
   Boston, MA 02111-1307, 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 
 
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 (*annotate_starting_hook) (void);
39 
void (*annotate_stopped_hook) (void);
40 
void (*annotate_signalled_hook) (void);
41 
void (*annotate_signal_hook) (void);
42 
void (*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 
 
55 
void
56 
breakpoints_changed (void)
57 
{
58 
  if (annotation_level > 1)
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 (annotate_starting_hook)
106 
    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 (annotate_stopped_hook)
120 
    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 (annotate_exited_hook)
137 
    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 (annotate_signalled_hook)
149 
    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 > 1)
159 
    printf_filtered ("\n\032\032signal-name\n");
160 
}
161 
 
162 
void
163 
annotate_signal_name_end (void)
164 
{
165 
  if (annotation_level > 1)
166 
    printf_filtered ("\n\032\032signal-name-end\n");
167 
}
168 
 
169 
void
170 
annotate_signal_string (void)
171 
{
172 
  if (annotation_level > 1)
173 
    printf_filtered ("\n\032\032signal-string\n");
174 
}
175 
 
176 
void
177 
annotate_signal_string_end (void)
178 
{
179 
  if (annotation_level > 1)
180 
    printf_filtered ("\n\032\032signal-string-end\n");
181 
}
182 
 
183 
void
184 
annotate_signal (void)
185 
{
186 
  if (annotate_signal_hook)
187 
    annotate_signal_hook ();
188 
 
189 
  if (annotation_level > 1)
190 
    printf_filtered ("\n\032\032signal\n");
191 
}
192 
 
193 
void
194 
annotate_breakpoints_headers (void)
195 
{
196 
  if (annotation_level > 1)
197 
    printf_filtered ("\n\032\032breakpoints-headers\n");
198 
}
199 
 
200 
void
201 
annotate_field (int num)
202 
{
203 
  if (annotation_level > 1)
204 
    printf_filtered ("\n\032\032field %d\n", num);
205 
}
206 
 
207 
void
208 
annotate_breakpoints_table (void)
209 
{
210 
  if (annotation_level > 1)
211 
    printf_filtered ("\n\032\032breakpoints-table\n");
212 
}
213 
 
214 
void
215 
annotate_record (void)
216 
{
217 
  if (annotation_level > 1)
218 
    printf_filtered ("\n\032\032record\n");
219 
}
220 
 
221 
void
222 
annotate_breakpoints_table_end (void)
223 
{
224 
  if (annotation_level > 1)
225 
    printf_filtered ("\n\032\032breakpoints-table-end\n");
226 
}
227 
 
228 
void
229 
annotate_frames_invalid (void)
230 
{
231 
  if (annotation_level > 1)
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 > 1)
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 > 1)
253 
    printf_filtered ("\n\032\032field-name-end\n");
254 
}
255 
 
256 
void
257 
annotate_field_value (void)
258 
{
259 
  if (annotation_level > 1)
260 
    printf_filtered ("\n\032\032field-value\n");
261 
}
262 
 
263 
void
264 
annotate_field_end (void)
265 
{
266 
  if (annotation_level > 1)
267 
    printf_filtered ("\n\032\032field-end\n");
268 
}
269 
 
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 > 1)
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 > 1)
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 > 1)
317 
    printf_filtered ("\n\032\032value-history-value\n");
318 
}
319 
 
320 
void
321 
annotate_value_history_end (void)
322 
{
323 
  if (annotation_level > 1)
324 
    printf_filtered ("\n\032\032value-history-end\n");
325 
}
326 
 
327 
void
328 
annotate_value_end (void)
329 
{
330 
  if (annotation_level > 1)
331 
    printf_filtered ("\n\032\032value-end\n");
332 
}
333 
 
334 
void
335 
annotate_display_begin (void)
336 
{
337 
  if (annotation_level > 1)
338 
    printf_filtered ("\n\032\032display-begin\n");
339 
}
340 
 
341 
void
342 
annotate_display_number_end (void)
343 
{
344 
  if (annotation_level > 1)
345 
    printf_filtered ("\n\032\032display-number-end\n");
346 
}
347 
 
348 
void
349 
annotate_display_format (void)
350 
{
351 
  if (annotation_level > 1)
352 
    printf_filtered ("\n\032\032display-format\n");
353 
}
354 
 
355 
void
356 
annotate_display_expression (void)
357 
{
358 
  if (annotation_level > 1)
359 
    printf_filtered ("\n\032\032display-expression\n");
360 
}
361 
 
362 
void
363 
annotate_display_expression_end (void)
364 
{
365 
  if (annotation_level > 1)
366 
    printf_filtered ("\n\032\032display-expression-end\n");
367 
}
368 
 
369 
void
370 
annotate_display_value (void)
371 
{
372 
  if (annotation_level > 1)
373 
    printf_filtered ("\n\032\032display-value\n");
374 
}
375 
 
376 
void
377 
annotate_display_end (void)
378 
{
379 
  if (annotation_level > 1)
380 
    printf_filtered ("\n\032\032display-end\n");
381 
}
382 
 
383 
void
384 
annotate_arg_begin (void)
385 
{
386 
  if (annotation_level > 1)
387 
    printf_filtered ("\n\032\032arg-begin\n");
388 
}
389 
 
390 
void
391 
annotate_arg_name_end (void)
392 
{
393 
  if (annotation_level > 1)
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 > 1)
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 > 1)
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 
  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 
      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 > 1)
445 
    printf_filtered ("\n\032\032function-call\n");
446 
}
447 
 
448 
void
449 
annotate_signal_handler_caller (void)
450 
{
451 
  if (annotation_level > 1)
452 
    printf_filtered ("\n\032\032signal-handler-caller\n");
453 
}
454 
 
455 
void
456 
annotate_frame_address (void)
457 
{
458 
  if (annotation_level > 1)
459 
    printf_filtered ("\n\032\032frame-address\n");
460 
}
461 
 
462 
void
463 
annotate_frame_address_end (void)
464 
{
465 
  if (annotation_level > 1)
466 
    printf_filtered ("\n\032\032frame-address-end\n");
467 
}
468 
 
469 
void
470 
annotate_frame_function_name (void)
471 
{
472 
  if (annotation_level > 1)
473 
    printf_filtered ("\n\032\032frame-function-name\n");
474 
}
475 
 
476 
void
477 
annotate_frame_args (void)
478 
{
479 
  if (annotation_level > 1)
480 
    printf_filtered ("\n\032\032frame-args\n");
481 
}
482 
 
483 
void
484 
annotate_frame_source_begin (void)
485 
{
486 
  if (annotation_level > 1)
487 
    printf_filtered ("\n\032\032frame-source-begin\n");
488 
}
489 
 
490 
void
491 
annotate_frame_source_file (void)
492 
{
493 
  if (annotation_level > 1)
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 > 1)
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 > 1)
508 
    printf_filtered ("\n\032\032frame-source-line\n");
509 
}
510 
 
511 
void
512 
annotate_frame_source_end (void)
513 
{
514 
  if (annotation_level > 1)
515 
    printf_filtered ("\n\032\032frame-source-end\n");
516 
}
517 
 
518 
void
519 
annotate_frame_where (void)
520 
{
521 
  if (annotation_level > 1)
522 
    printf_filtered ("\n\032\032frame-where\n");
523 
}
524 
 
525 
void
526 
annotate_frame_end (void)
527 
{
528 
  if (annotation_level > 1)
529 
    printf_filtered ("\n\032\032frame-end\n");
530 
}
531 
 
532 
void
533 
annotate_array_section_begin (int index, struct type *elttype)
534 
{
535 
  if (annotation_level > 1)
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 > 1)
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 > 1)
554 
    printf_filtered ("\n\032\032elt-rep-end\n");
555 
}
556 
 
557 
void
558 
annotate_elt (void)
559 
{
560 
  if (annotation_level > 1)
561 
    printf_filtered ("\n\032\032elt\n");
562 
}
563 
 
564 
void
565 
annotate_array_section_end (void)
566 
{
567 
  if (annotation_level > 1)
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 > 1)
581 
    {
582 
      delete_breakpoint_hook = breakpoint_changed;
583 
      modify_breakpoint_hook = breakpoint_changed;
584 
    }
585 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.