1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "defs.h"
22 #include "gdb_obstack.h"
23 #include "bfd.h" /* Binary File Description */
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "value.h"
28 #include "gdbcore.h"
29 #include "target.h"
30 #include "command.h"
31 #include "gdbcmd.h"
32 #include "language.h"
33 #include "demangle.h"
34 #include "c-lang.h"
35 #include "typeprint.h"
36 #include "ada-lang.h"
37
38 #include <ctype.h>
39 #include "gdb_string.h"
40 #include <errno.h>
41
42 static int print_record_field_types (struct type *, struct type *,
43 struct ui_file *, int, int);
44
45 static void print_array_type (struct type *, struct ui_file *, int, int);
46
47 static void print_choices (struct type *, int, struct ui_file *,
48 struct type *);
49
50 static void print_range (struct type *, struct ui_file *);
51
52 static void print_range_bound (struct type *, char *, int *,
53 struct ui_file *);
54
55 static void
56 print_dynamic_range_bound (struct type *, const char *, int,
57 const char *, struct ui_file *);
58
59 static void print_range_type_named (char *, struct ui_file *);
60
61
62
63 static char *name_buffer;
64 static int name_buffer_len;
65
66 /* The (decoded) Ada name of TYPE. This value persists until the
67 next call. */
68
69 static char *
decoded_type_name(struct type * type)70 decoded_type_name (struct type *type)
71 {
72 if (ada_type_name (type) == NULL)
73 return NULL;
74 else
75 {
76 char *raw_name = ada_type_name (type);
77 char *s, *q;
78
79 if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
80 {
81 name_buffer_len = 16 + 2 * strlen (raw_name);
82 name_buffer = xrealloc (name_buffer, name_buffer_len);
83 }
84 strcpy (name_buffer, raw_name);
85
86 s = (char *) strstr (name_buffer, "___");
87 if (s != NULL)
88 *s = '\0';
89
90 s = name_buffer + strlen (name_buffer) - 1;
91 while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
92 s -= 1;
93
94 if (s == name_buffer)
95 return name_buffer;
96
97 if (!islower (s[1]))
98 return NULL;
99
100 for (s = q = name_buffer; *s != '\0'; q += 1)
101 {
102 if (s[0] == '_' && s[1] == '_')
103 {
104 *q = '.';
105 s += 2;
106 }
107 else
108 {
109 *q = *s;
110 s += 1;
111 }
112 }
113 *q = '\0';
114 return name_buffer;
115 }
116 }
117
118
119 /* Print a description of a type in the format of a
120 typedef for the current language.
121 NEW is the new name for a type TYPE. */
122
123 void
ada_typedef_print(struct type * type,struct symbol * new,struct ui_file * stream)124 ada_typedef_print (struct type *type, struct symbol *new,
125 struct ui_file *stream)
126 {
127 fprintf_filtered (stream, "type %.*s is ",
128 ada_name_prefix_len (SYMBOL_PRINT_NAME (new)),
129 SYMBOL_PRINT_NAME (new));
130 type_print (type, "", stream, 1);
131 }
132
133 /* Print range type TYPE on STREAM. */
134
135 static void
print_range(struct type * type,struct ui_file * stream)136 print_range (struct type *type, struct ui_file *stream)
137 {
138 struct type *target_type;
139 target_type = TYPE_TARGET_TYPE (type);
140 if (target_type == NULL)
141 target_type = type;
142
143 switch (TYPE_CODE (target_type))
144 {
145 case TYPE_CODE_RANGE:
146 case TYPE_CODE_INT:
147 case TYPE_CODE_BOOL:
148 case TYPE_CODE_CHAR:
149 case TYPE_CODE_ENUM:
150 break;
151 default:
152 target_type = builtin_type_int;
153 break;
154 }
155
156 if (TYPE_NFIELDS (type) < 2)
157 {
158 /* A range needs at least 2 bounds to be printed. If there are less
159 than 2, just print the type name instead of the range itself.
160 This check handles cases such as characters, for example.
161
162 Note that if the name is not defined, then we don't print anything.
163 */
164 fprintf_filtered (stream, "%.*s",
165 ada_name_prefix_len (TYPE_NAME (type)),
166 TYPE_NAME (type));
167 }
168 else
169 {
170 /* We extract the range type bounds respectively from the first element
171 and the last element of the type->fields array */
172 const LONGEST lower_bound = (LONGEST) TYPE_LOW_BOUND (type);
173 const LONGEST upper_bound =
174 (LONGEST) TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
175
176 ada_print_scalar (target_type, lower_bound, stream);
177 fprintf_filtered (stream, " .. ");
178 ada_print_scalar (target_type, upper_bound, stream);
179 }
180 }
181
182 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
183 set *N past the bound and its delimiter, if any. */
184
185 static void
print_range_bound(struct type * type,char * bounds,int * n,struct ui_file * stream)186 print_range_bound (struct type *type, char *bounds, int *n,
187 struct ui_file *stream)
188 {
189 LONGEST B;
190 if (ada_scan_number (bounds, *n, &B, n))
191 {
192 /* STABS decodes all range types which bounds are 0 .. -1 as
193 unsigned integers (ie. the type code is TYPE_CODE_INT, not
194 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
195 on the unsigned flag to determine whether the bound should
196 be printed as a signed or an unsigned value. This causes
197 the upper bound of the 0 .. -1 range types to be printed as
198 a very large unsigned number instead of -1.
199 To workaround this stabs deficiency, we replace the TYPE by
200 builtin_type_long when we detect that the bound is negative,
201 and the type is a TYPE_CODE_INT. The bound is negative when
202 'm' is the last character of the number scanned in BOUNDS. */
203 if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
204 type = builtin_type_long;
205 ada_print_scalar (type, B, stream);
206 if (bounds[*n] == '_')
207 *n += 2;
208 }
209 else
210 {
211 int bound_len;
212 char *bound = bounds + *n;
213 char *pend;
214
215 pend = strstr (bound, "__");
216 if (pend == NULL)
217 *n += bound_len = strlen (bound);
218 else
219 {
220 bound_len = pend - bound;
221 *n += bound_len + 2;
222 }
223 fprintf_filtered (stream, "%.*s", bound_len, bound);
224 }
225 }
226
227 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
228 the value (if found) of the bound indicated by SUFFIX ("___L" or
229 "___U") according to the ___XD conventions. */
230
231 static void
print_dynamic_range_bound(struct type * type,const char * name,int name_len,const char * suffix,struct ui_file * stream)232 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
233 const char *suffix, struct ui_file *stream)
234 {
235 static char *name_buf = NULL;
236 static size_t name_buf_len = 0;
237 LONGEST B;
238 int OK;
239
240 GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
241 strncpy (name_buf, name, name_len);
242 strcpy (name_buf + name_len, suffix);
243
244 B = get_int_var_value (name_buf, &OK);
245 if (OK)
246 ada_print_scalar (type, B, stream);
247 else
248 fprintf_filtered (stream, "?");
249 }
250
251 /* Print the range type named NAME. */
252
253 static void
print_range_type_named(char * name,struct ui_file * stream)254 print_range_type_named (char *name, struct ui_file *stream)
255 {
256 struct type *raw_type = ada_find_any_type (name);
257 struct type *base_type;
258 char *subtype_info;
259
260 if (raw_type == NULL)
261 base_type = builtin_type_int;
262 else if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
263 base_type = TYPE_TARGET_TYPE (raw_type);
264 else
265 base_type = raw_type;
266
267 subtype_info = strstr (name, "___XD");
268 if (subtype_info == NULL && raw_type == NULL)
269 fprintf_filtered (stream, "? .. ?");
270 else if (subtype_info == NULL)
271 print_range (raw_type, stream);
272 else
273 {
274 int prefix_len = subtype_info - name;
275 char *bounds_str;
276 int n;
277
278 subtype_info += 5;
279 bounds_str = strchr (subtype_info, '_');
280 n = 1;
281
282 if (*subtype_info == 'L')
283 {
284 print_range_bound (base_type, bounds_str, &n, stream);
285 subtype_info += 1;
286 }
287 else
288 print_dynamic_range_bound (base_type, name, prefix_len, "___L",
289 stream);
290
291 fprintf_filtered (stream, " .. ");
292
293 if (*subtype_info == 'U')
294 print_range_bound (base_type, bounds_str, &n, stream);
295 else
296 print_dynamic_range_bound (base_type, name, prefix_len, "___U",
297 stream);
298 }
299 }
300
301 /* Print enumerated type TYPE on STREAM. */
302
303 static void
print_enum_type(struct type * type,struct ui_file * stream)304 print_enum_type (struct type *type, struct ui_file *stream)
305 {
306 int len = TYPE_NFIELDS (type);
307 int i, lastval;
308
309 fprintf_filtered (stream, "(");
310 wrap_here (" ");
311
312 lastval = 0;
313 for (i = 0; i < len; i++)
314 {
315 QUIT;
316 if (i)
317 fprintf_filtered (stream, ", ");
318 wrap_here (" ");
319 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
320 if (lastval != TYPE_FIELD_BITPOS (type, i))
321 {
322 fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
323 lastval = TYPE_FIELD_BITPOS (type, i);
324 }
325 lastval += 1;
326 }
327 fprintf_filtered (stream, ")");
328 }
329
330 /* Print representation of Ada fixed-point type TYPE on STREAM. */
331
332 static void
print_fixed_point_type(struct type * type,struct ui_file * stream)333 print_fixed_point_type (struct type *type, struct ui_file *stream)
334 {
335 DOUBLEST delta = ada_delta (type);
336 DOUBLEST small = ada_fixed_to_float (type, 1.0);
337
338 if (delta < 0.0)
339 fprintf_filtered (stream, "delta ??");
340 else
341 {
342 fprintf_filtered (stream, "delta %g", (double) delta);
343 if (delta != small)
344 fprintf_filtered (stream, " <'small = %g>", (double) small);
345 }
346 }
347
348 /* Print representation of special VAX floating-point type TYPE on STREAM. */
349
350 static void
print_vax_floating_point_type(struct type * type,struct ui_file * stream)351 print_vax_floating_point_type (struct type *type, struct ui_file *stream)
352 {
353 fprintf_filtered (stream, "<float format %c>",
354 ada_vax_float_type_suffix (type));
355 }
356
357 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
358 recursion (indentation) level, in case the element type itself has
359 nested structure, and SHOW is the number of levels of internal
360 structure to show (see ada_print_type). */
361
362 static void
print_array_type(struct type * type,struct ui_file * stream,int show,int level)363 print_array_type (struct type *type, struct ui_file *stream, int show,
364 int level)
365 {
366 int bitsize;
367 int n_indices;
368
369 bitsize = 0;
370 fprintf_filtered (stream, "array (");
371
372 n_indices = -1;
373 if (show < 0)
374 fprintf_filtered (stream, "...");
375 else
376 {
377 if (ada_is_packed_array_type (type))
378 type = ada_coerce_to_simple_array_type (type);
379 if (type == NULL)
380 {
381 fprintf_filtered (stream, "<undecipherable array type>");
382 return;
383 }
384 if (ada_is_simple_array_type (type))
385 {
386 struct type *range_desc_type =
387 ada_find_parallel_type (type, "___XA");
388 struct type *arr_type;
389
390 bitsize = 0;
391 if (range_desc_type == NULL)
392 {
393 for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
394 arr_type = TYPE_TARGET_TYPE (arr_type))
395 {
396 if (arr_type != type)
397 fprintf_filtered (stream, ", ");
398 print_range (TYPE_INDEX_TYPE (arr_type), stream);
399 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
400 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
401 }
402 }
403 else
404 {
405 int k;
406 n_indices = TYPE_NFIELDS (range_desc_type);
407 for (k = 0, arr_type = type;
408 k < n_indices;
409 k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
410 {
411 if (k > 0)
412 fprintf_filtered (stream, ", ");
413 print_range_type_named (TYPE_FIELD_NAME
414 (range_desc_type, k), stream);
415 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
416 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
417 }
418 }
419 }
420 else
421 {
422 int i, i0;
423 for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
424 fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
425 }
426 }
427
428 fprintf_filtered (stream, ") of ");
429 wrap_here ("");
430 ada_print_type (ada_array_element_type (type, n_indices), "", stream,
431 show == 0 ? 0 : show - 1, level + 1);
432 if (bitsize > 0)
433 fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
434 }
435
436 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
437 STREAM, assuming the VAL_TYPE is the type of the values. */
438
439 static void
print_choices(struct type * type,int field_num,struct ui_file * stream,struct type * val_type)440 print_choices (struct type *type, int field_num, struct ui_file *stream,
441 struct type *val_type)
442 {
443 int have_output;
444 int p;
445 const char *name = TYPE_FIELD_NAME (type, field_num);
446
447 have_output = 0;
448
449 /* Skip over leading 'V': NOTE soon to be obsolete. */
450 if (name[0] == 'V')
451 {
452 if (!ada_scan_number (name, 1, NULL, &p))
453 goto Huh;
454 }
455 else
456 p = 0;
457
458 while (1)
459 {
460 switch (name[p])
461 {
462 default:
463 return;
464 case 'S':
465 case 'R':
466 case 'O':
467 if (have_output)
468 fprintf_filtered (stream, " | ");
469 have_output = 1;
470 break;
471 }
472
473 switch (name[p])
474 {
475 case 'S':
476 {
477 LONGEST W;
478 if (!ada_scan_number (name, p + 1, &W, &p))
479 goto Huh;
480 ada_print_scalar (val_type, W, stream);
481 break;
482 }
483 case 'R':
484 {
485 LONGEST L, U;
486 if (!ada_scan_number (name, p + 1, &L, &p)
487 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
488 goto Huh;
489 ada_print_scalar (val_type, L, stream);
490 fprintf_filtered (stream, " .. ");
491 ada_print_scalar (val_type, U, stream);
492 break;
493 }
494 case 'O':
495 fprintf_filtered (stream, "others");
496 p += 1;
497 break;
498 }
499 }
500
501 Huh:
502 fprintf_filtered (stream, "??");
503
504 }
505
506 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
507 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
508 LEVEL is the recursion
509 (indentation) level, in case any of the fields themselves have
510 nested structure, and SHOW is the number of levels of internal structure
511 to show (see ada_print_type). For this purpose, fields nested in a
512 variant part are taken to be at the same level as the fields
513 immediately outside the variant part. */
514
515 static void
print_variant_clauses(struct type * type,int field_num,struct type * outer_type,struct ui_file * stream,int show,int level)516 print_variant_clauses (struct type *type, int field_num,
517 struct type *outer_type, struct ui_file *stream,
518 int show, int level)
519 {
520 int i;
521 struct type *var_type, *par_type;
522 struct type *discr_type;
523
524 var_type = TYPE_FIELD_TYPE (type, field_num);
525 discr_type = ada_variant_discrim_type (var_type, outer_type);
526
527 if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
528 {
529 var_type = TYPE_TARGET_TYPE (var_type);
530 if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
531 return;
532 }
533
534 par_type = ada_find_parallel_type (var_type, "___XVU");
535 if (par_type != NULL)
536 var_type = par_type;
537
538 for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
539 {
540 fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
541 print_choices (var_type, i, stream, discr_type);
542 fprintf_filtered (stream, " =>");
543 if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
544 outer_type, stream, show, level + 4) <= 0)
545 fprintf_filtered (stream, " null;");
546 }
547 }
548
549 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
550 discriminants are contained in OUTER_TYPE, print a description of it
551 on STREAM. LEVEL is the recursion (indentation) level, in case any of
552 the fields themselves have nested structure, and SHOW is the number of
553 levels of internal structure to show (see ada_print_type). For this
554 purpose, fields nested in a variant part are taken to be at the same
555 level as the fields immediately outside the variant part. */
556
557 static void
print_variant_part(struct type * type,int field_num,struct type * outer_type,struct ui_file * stream,int show,int level)558 print_variant_part (struct type *type, int field_num, struct type *outer_type,
559 struct ui_file *stream, int show, int level)
560 {
561 fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
562 ada_variant_discrim_name
563 (TYPE_FIELD_TYPE (type, field_num)));
564 print_variant_clauses (type, field_num, outer_type, stream, show,
565 level + 4);
566 fprintf_filtered (stream, "\n%*send case;", level + 4, "");
567 }
568
569 /* Print a description on STREAM of the fields in record type TYPE, whose
570 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
571 level, in case any of the fields themselves have nested structure,
572 and SHOW is the number of levels of internal structure to show
573 (see ada_print_type). Does not print parent type information of TYPE.
574 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
575 Prints each field beginning on a new line, but does not put a new line at
576 end. */
577
578 static int
print_record_field_types(struct type * type,struct type * outer_type,struct ui_file * stream,int show,int level)579 print_record_field_types (struct type *type, struct type *outer_type,
580 struct ui_file *stream, int show, int level)
581 {
582 int len, i, flds;
583
584 flds = 0;
585 len = TYPE_NFIELDS (type);
586
587 if (len == 0 && (TYPE_FLAGS (type) & TYPE_FLAG_STUB) != 0)
588 return -1;
589
590 for (i = 0; i < len; i += 1)
591 {
592 QUIT;
593
594 if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
595 ;
596 else if (ada_is_wrapper_field (type, i))
597 flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
598 stream, show, level);
599 else if (ada_is_variant_part (type, i))
600 {
601 print_variant_part (type, i, outer_type, stream, show, level);
602 flds = 1;
603 }
604 else
605 {
606 flds += 1;
607 fprintf_filtered (stream, "\n%*s", level + 4, "");
608 ada_print_type (TYPE_FIELD_TYPE (type, i),
609 TYPE_FIELD_NAME (type, i),
610 stream, show - 1, level + 4);
611 fprintf_filtered (stream, ";");
612 }
613 }
614
615 return flds;
616 }
617
618 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
619 level, in case the element type itself has nested structure, and SHOW is
620 the number of levels of internal structure to show (see ada_print_type). */
621
622 static void
print_record_type(struct type * type0,struct ui_file * stream,int show,int level)623 print_record_type (struct type *type0, struct ui_file *stream, int show,
624 int level)
625 {
626 struct type *parent_type;
627 struct type *type;
628
629 type = ada_find_parallel_type (type0, "___XVE");
630 if (type == NULL)
631 type = type0;
632
633 parent_type = ada_parent_type (type);
634 if (ada_type_name (parent_type) != NULL)
635 fprintf_filtered (stream, "new %s with ",
636 decoded_type_name (parent_type));
637 else if (parent_type == NULL && ada_is_tagged_type (type, 0))
638 fprintf_filtered (stream, "tagged ");
639
640 fprintf_filtered (stream, "record");
641
642 if (show < 0)
643 fprintf_filtered (stream, " ... end record");
644 else
645 {
646 int flds;
647
648 flds = 0;
649 if (parent_type != NULL && ada_type_name (parent_type) == NULL)
650 flds += print_record_field_types (parent_type, parent_type,
651 stream, show, level);
652 flds += print_record_field_types (type, type, stream, show, level);
653
654 if (flds > 0)
655 fprintf_filtered (stream, "\n%*send record", level, "");
656 else if (flds < 0)
657 fprintf_filtered (stream, " <incomplete type> end record");
658 else
659 fprintf_filtered (stream, " null; end record");
660 }
661 }
662
663 /* Print the unchecked union type TYPE in something resembling Ada
664 format on STREAM. LEVEL is the recursion (indentation) level
665 in case the element type itself has nested structure, and SHOW is the
666 number of levels of internal structure to show (see ada_print_type). */
667 static void
print_unchecked_union_type(struct type * type,struct ui_file * stream,int show,int level)668 print_unchecked_union_type (struct type *type, struct ui_file *stream,
669 int show, int level)
670 {
671 fprintf_filtered (stream, "record (?) is");
672
673 if (show < 0)
674 fprintf_filtered (stream, " ... end record");
675 else if (TYPE_NFIELDS (type) == 0)
676 fprintf_filtered (stream, " null; end record");
677 else
678 {
679 int i;
680
681 fprintf_filtered (stream, "\n%*scase ? is", level + 4, "");
682
683 for (i = 0; i < TYPE_NFIELDS (type); i += 1)
684 {
685 fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
686 level + 12, "");
687 ada_print_type (TYPE_FIELD_TYPE (type, i),
688 TYPE_FIELD_NAME (type, i),
689 stream, show - 1, level + 12);
690 fprintf_filtered (stream, ";");
691 }
692
693 fprintf_filtered (stream, "\n%*send case;\n%*send record",
694 level + 4, "", level, "");
695 }
696 }
697
698
699
700 /* Print function or procedure type TYPE on STREAM. Make it a header
701 for function or procedure NAME if NAME is not null. */
702
703 static void
print_func_type(struct type * type,struct ui_file * stream,char * name)704 print_func_type (struct type *type, struct ui_file *stream, char *name)
705 {
706 int i, len = TYPE_NFIELDS (type);
707
708 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
709 fprintf_filtered (stream, "procedure");
710 else
711 fprintf_filtered (stream, "function");
712
713 if (name != NULL && name[0] != '\0')
714 fprintf_filtered (stream, " %s", name);
715
716 if (len > 0)
717 {
718 fprintf_filtered (stream, " (");
719 for (i = 0; i < len; i += 1)
720 {
721 if (i > 0)
722 {
723 fputs_filtered ("; ", stream);
724 wrap_here (" ");
725 }
726 fprintf_filtered (stream, "a%d: ", i + 1);
727 ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
728 }
729 fprintf_filtered (stream, ")");
730 }
731
732 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
733 {
734 fprintf_filtered (stream, " return ");
735 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
736 }
737 }
738
739
740 /* Print a description of a type TYPE0.
741 Output goes to STREAM (via stdio).
742 If VARSTRING is a non-empty string, print as an Ada variable/field
743 declaration.
744 SHOW+1 is the maximum number of levels of internal type structure
745 to show (this applies to record types, enumerated types, and
746 array types).
747 SHOW is the number of levels of internal type structure to show
748 when there is a type name for the SHOWth deepest level (0th is
749 outer level).
750 When SHOW<0, no inner structure is shown.
751 LEVEL indicates level of recursion (for nested definitions). */
752
753 void
ada_print_type(struct type * type0,char * varstring,struct ui_file * stream,int show,int level)754 ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
755 int show, int level)
756 {
757 struct type *type = ada_check_typedef (ada_get_base_type (type0));
758 char *type_name = decoded_type_name (type);
759 int is_var_decl = (varstring != NULL && varstring[0] != '\0');
760
761 if (type == NULL)
762 {
763 if (is_var_decl)
764 fprintf_filtered (stream, "%.*s: ",
765 ada_name_prefix_len (varstring), varstring);
766 fprintf_filtered (stream, "<null type?>");
767 return;
768 }
769
770 if (show > 0)
771 type = ada_check_typedef (type);
772
773 if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
774 fprintf_filtered (stream, "%.*s: ",
775 ada_name_prefix_len (varstring), varstring);
776
777 if (type_name != NULL && show <= 0)
778 {
779 fprintf_filtered (stream, "%.*s",
780 ada_name_prefix_len (type_name), type_name);
781 return;
782 }
783
784 if (ada_is_aligner_type (type))
785 ada_print_type (ada_aligned_type (type), "", stream, show, level);
786 else if (ada_is_packed_array_type (type))
787 print_array_type (type, stream, show, level);
788 else
789 switch (TYPE_CODE (type))
790 {
791 default:
792 fprintf_filtered (stream, "<");
793 c_print_type (type, "", stream, show, level);
794 fprintf_filtered (stream, ">");
795 break;
796 case TYPE_CODE_PTR:
797 fprintf_filtered (stream, "access ");
798 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
799 break;
800 case TYPE_CODE_REF:
801 fprintf_filtered (stream, "<ref> ");
802 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
803 break;
804 case TYPE_CODE_ARRAY:
805 print_array_type (type, stream, show, level);
806 break;
807 case TYPE_CODE_INT:
808 if (ada_is_fixed_point_type (type))
809 print_fixed_point_type (type, stream);
810 else if (ada_is_vax_floating_type (type))
811 print_vax_floating_point_type (type, stream);
812 else
813 {
814 char *name = ada_type_name (type);
815 if (!ada_is_range_type_name (name))
816 fprintf_filtered (stream, "<%d-byte integer>",
817 TYPE_LENGTH (type));
818 else
819 {
820 fprintf_filtered (stream, "range ");
821 print_range_type_named (name, stream);
822 }
823 }
824 break;
825 case TYPE_CODE_RANGE:
826 if (ada_is_fixed_point_type (type))
827 print_fixed_point_type (type, stream);
828 else if (ada_is_vax_floating_type (type))
829 print_vax_floating_point_type (type, stream);
830 else if (ada_is_modular_type (type))
831 fprintf_filtered (stream, "mod %ld", (long) ada_modulus (type));
832 else
833 {
834 fprintf_filtered (stream, "range ");
835 print_range (type, stream);
836 }
837 break;
838 case TYPE_CODE_FLT:
839 fprintf_filtered (stream, "<%d-byte float>", TYPE_LENGTH (type));
840 break;
841 case TYPE_CODE_ENUM:
842 if (show < 0)
843 fprintf_filtered (stream, "(...)");
844 else
845 print_enum_type (type, stream);
846 break;
847 case TYPE_CODE_STRUCT:
848 if (ada_is_array_descriptor_type (type))
849 print_array_type (type, stream, show, level);
850 else if (ada_is_bogus_array_descriptor (type))
851 fprintf_filtered (stream,
852 "array (?) of ? (<mal-formed descriptor>)");
853 else
854 print_record_type (type, stream, show, level);
855 break;
856 case TYPE_CODE_UNION:
857 print_unchecked_union_type (type, stream, show, level);
858 break;
859 case TYPE_CODE_FUNC:
860 print_func_type (type, stream, varstring);
861 break;
862 }
863 }
864