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