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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [annotate.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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