gdb/p-typeprint.c

   1 /* Support for printing Pascal types for GDB, the GNU debugger.
   2    Copyright (C) 2000-2021 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 3 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, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* This file is derived from p-typeprint.c */
  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 "language.h"
  31 #include "p-lang.h"
  32 #include "typeprint.h"
  33 #include "gdb-demangle.h"
  34 #include <ctype.h>
  35 #include "cli/cli-style.h"
  36
  37 /* See language.h.  */
  38
  39 void
  40 pascal_language::print_type (struct type *type, const char *varstring,
  41                              struct ui_file *stream, int show, int level,
  42                              const struct type_print_options *flags) const
  43 {
  44   enum type_code code;
  45   int demangled_args;
  46
  47   code = type->code ();
  48
  49   if (show > 0)
  50     type = check_typedef (type);
  51
  52   if ((code == TYPE_CODE_FUNC
  53        || code == TYPE_CODE_METHOD))
  54     {
  55       type_print_varspec_prefix (type, stream, show, 0, flags);
  56     }
  57   /* first the name */
  58   fputs_filtered (varstring, stream);
  59
  60   if ((varstring != NULL && *varstring != '\0')
  61       && !(code == TYPE_CODE_FUNC
  62            || code == TYPE_CODE_METHOD))
  63     {
  64       fputs_filtered (" : ", stream);
  65     }
  66
  67   if (!(code == TYPE_CODE_FUNC
  68         || code == TYPE_CODE_METHOD))
  69     {
  70       type_print_varspec_prefix (type, stream, show, 0, flags);
  71     }
  72
  73   type_print_base (type, stream, show, level, flags);
  74   /* For demangled function names, we have the arglist as part of the name,
  75      so don't print an additional pair of ()'s.  */
  76
  77   demangled_args = varstring ? strchr (varstring, '(') != NULL : 0;
  78   type_print_varspec_suffix (type, stream, show, 0, demangled_args,
  79                                     flags);
  80
  81 }
  82
  83 /* See language.h.  */
  84
  85 void
  86 pascal_language::print_typedef (struct type *type, struct symbol *new_symbol,
  87                                 struct ui_file *stream) const
  88 {
  89   type = check_typedef (type);
  90   fprintf_filtered (stream, "type ");
  91   fprintf_filtered (stream, "%s = ", new_symbol->print_name ());
  92   type_print (type, "", stream, 0);
  93   fprintf_filtered (stream, ";");
  94 }
  95
  96 /* See p-lang.h.  */
  97
  98 void
  99 pascal_language::type_print_derivation_info (struct ui_file *stream,
 100                                              struct type *type) const
 101 {
 102   const char *name;
 103   int i;
 104
 105   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 106     {
 107       fputs_filtered (i == 0 ? ": " : ", ", stream);
 108       fprintf_filtered (stream, "%s%s ",
 109                         BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private",
 110                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 111       name = TYPE_BASECLASS (type, i)->name ();
 112       fprintf_filtered (stream, "%s", name ? name : "(null)");
 113     }
 114   if (i > 0)
 115     {
 116       fputs_filtered (" ", stream);
 117     }
 118 }
 119
 120 /* See p-lang.h.  */
 121
 122 void
 123 pascal_language::type_print_method_args (const char *physname,
 124                                          const char *methodname,
 125                                          struct ui_file *stream) const
 126 {
 127   int is_constructor = (startswith (physname, "__ct__"));
 128   int is_destructor = (startswith (physname, "__dt__"));
 129
 130   if (is_constructor || is_destructor)
 131     {
 132       physname += 6;
 133     }
 134
 135   fputs_filtered (methodname, stream);
 136
 137   if (physname && (*physname != 0))
 138     {
 139       fputs_filtered (" (", stream);
 140       /* We must demangle this.  */
 141       while (isdigit (physname[0]))
 142         {
 143           int len = 0;
 144           int i, j;
 145           char *argname;
 146
 147           while (isdigit (physname[len]))
 148             {
 149               len++;
 150             }
 151           i = strtol (physname, &argname, 0);
 152           physname += len;
 153
 154           for (j = 0; j < i; ++j)
 155             fputc_filtered (physname[j], stream);
 156
 157           physname += i;
 158           if (physname[0] != 0)
 159             {
 160               fputs_filtered (", ", stream);
 161             }
 162         }
 163       fputs_filtered (")", stream);
 164     }
 165 }
 166
 167 /* See p-lang.h.  */
 168
 169 void
 170 pascal_language::type_print_varspec_prefix (struct type *type,
 171                                             struct ui_file *stream,
 172                                             int show, int passed_a_ptr,
 173                                             const struct type_print_options *flags) const
 174 {
 175   if (type == 0)
 176     return;
 177
 178   if (type->name () && show <= 0)
 179     return;
 180
 181   QUIT;
 182
 183   switch (type->code ())
 184     {
 185     case TYPE_CODE_PTR:
 186       fprintf_filtered (stream, "^");
 187       type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1,
 188                                         flags);
 189       break;                    /* Pointer should be handled normally
 190                                    in pascal.  */
 191
 192     case TYPE_CODE_METHOD:
 193       if (passed_a_ptr)
 194         fprintf_filtered (stream, "(");
 195       if (TYPE_TARGET_TYPE (type) != NULL
 196           && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 197         {
 198           fprintf_filtered (stream, "function  ");
 199         }
 200       else
 201         {
 202           fprintf_filtered (stream, "procedure ");
 203         }
 204
 205       if (passed_a_ptr)
 206         {
 207           fprintf_filtered (stream, " ");
 208           type_print_base (TYPE_SELF_TYPE (type),
 209                                   stream, 0, passed_a_ptr, flags);
 210           fprintf_filtered (stream, "::");
 211         }
 212       break;
 213
 214     case TYPE_CODE_REF:
 215       type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1,
 216                                  flags);
 217       fprintf_filtered (stream, "&");
 218       break;
 219
 220     case TYPE_CODE_FUNC:
 221       if (passed_a_ptr)
 222         fprintf_filtered (stream, "(");
 223
 224       if (TYPE_TARGET_TYPE (type) != NULL
 225           && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 226         {
 227           fprintf_filtered (stream, "function  ");
 228         }
 229       else
 230         {
 231           fprintf_filtered (stream, "procedure ");
 232         }
 233
 234       break;
 235
 236     case TYPE_CODE_ARRAY:
 237       if (passed_a_ptr)
 238         fprintf_filtered (stream, "(");
 239       fprintf_filtered (stream, "array ");
 240       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 241           && type->bounds ()->high.kind () != PROP_UNDEFINED)
 242         fprintf_filtered (stream, "[%s..%s] ",
 243                           plongest (type->bounds ()->low.const_val ()),
 244                           plongest (type->bounds ()->high.const_val ()));
 245       fprintf_filtered (stream, "of ");
 246       break;
 247
 248     case TYPE_CODE_UNDEF:
 249     case TYPE_CODE_STRUCT:
 250     case TYPE_CODE_UNION:
 251     case TYPE_CODE_ENUM:
 252     case TYPE_CODE_INT:
 253     case TYPE_CODE_FLT:
 254     case TYPE_CODE_VOID:
 255     case TYPE_CODE_ERROR:
 256     case TYPE_CODE_CHAR:
 257     case TYPE_CODE_BOOL:
 258     case TYPE_CODE_SET:
 259     case TYPE_CODE_RANGE:
 260     case TYPE_CODE_STRING:
 261     case TYPE_CODE_COMPLEX:
 262     case TYPE_CODE_TYPEDEF:
 263     case TYPE_CODE_FIXED_POINT:
 264       /* These types need no prefix.  They are listed here so that
 265          gcc -Wall will reveal any types that haven't been handled.  */
 266       break;
 267     default:
 268       gdb_assert_not_reached ("unexpected type");
 269       break;
 270     }
 271 }
 272
 273 /* See p-lang.h.  */
 274
 275 void
 276 pascal_language::print_func_args (struct type *type, struct ui_file *stream,
 277                                   const struct type_print_options *flags) const
 278 {
 279   int i, len = type->num_fields ();
 280
 281   if (len)
 282     {
 283       fprintf_filtered (stream, "(");
 284     }
 285   for (i = 0; i < len; i++)
 286     {
 287       if (i > 0)
 288         {
 289           fputs_filtered (", ", stream);
 290           wrap_here ("    ");
 291         }
 292       /*  Can we find if it is a var parameter ??
 293           if ( TYPE_FIELD(type, i) == )
 294           {
 295             fprintf_filtered (stream, "var ");
 296           } */
 297       print_type (type->field (i).type (), ""   /* TYPE_FIELD_NAME
 298                                                    seems invalid!  */
 299                          ,stream, -1, 0, flags);
 300     }
 301   if (len)
 302     {
 303       fprintf_filtered (stream, ")");
 304     }
 305 }
 306
 307 /* See p-lang.h.  */
 308
 309 void
 310 pascal_language::type_print_func_varspec_suffix  (struct type *type,
 311                                                   struct ui_file *stream,
 312                                                   int show, int passed_a_ptr,
 313                                                   int demangled_args,
 314                                                   const struct type_print_options *flags) const
 315 {
 316   if (TYPE_TARGET_TYPE (type) == NULL
 317       || TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 318     {
 319       fprintf_filtered (stream, " : ");
 320       type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 321                                         stream, 0, 0, flags);
 322
 323       if (TYPE_TARGET_TYPE (type) == NULL)
 324         type_print_unknown_return_type (stream);
 325       else
 326         type_print_base (TYPE_TARGET_TYPE (type), stream, show, 0,
 327                                 flags);
 328
 329       type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 330                                  passed_a_ptr, 0, flags);
 331     }
 332 }
 333
 334 /* See p-lang.h.  */
 335
 336 void
 337 pascal_language::type_print_varspec_suffix (struct type *type,
 338                                             struct ui_file *stream,
 339                                             int show, int passed_a_ptr,
 340                                             int demangled_args,
 341                                             const struct type_print_options *flags) const
 342 {
 343   if (type == 0)
 344     return;
 345
 346   if (type->name () && show <= 0)
 347     return;
 348
 349   QUIT;
 350
 351   switch (type->code ())
 352     {
 353     case TYPE_CODE_ARRAY:
 354       if (passed_a_ptr)
 355         fprintf_filtered (stream, ")");
 356       break;
 357
 358     case TYPE_CODE_METHOD:
 359       if (passed_a_ptr)
 360         fprintf_filtered (stream, ")");
 361       type_print_method_args ("", "", stream);
 362       type_print_func_varspec_suffix (type, stream, show,
 363                                              passed_a_ptr, 0, flags);
 364       break;
 365
 366     case TYPE_CODE_PTR:
 367     case TYPE_CODE_REF:
 368       type_print_varspec_suffix (TYPE_TARGET_TYPE (type),
 369                                  stream, 0, 1, 0, flags);
 370       break;
 371
 372     case TYPE_CODE_FUNC:
 373       if (passed_a_ptr)
 374         fprintf_filtered (stream, ")");
 375       if (!demangled_args)
 376         print_func_args (type, stream, flags);
 377       type_print_func_varspec_suffix (type, stream, show,
 378                                              passed_a_ptr, 0, flags);
 379       break;
 380
 381     case TYPE_CODE_UNDEF:
 382     case TYPE_CODE_STRUCT:
 383     case TYPE_CODE_UNION:
 384     case TYPE_CODE_ENUM:
 385     case TYPE_CODE_INT:
 386     case TYPE_CODE_FLT:
 387     case TYPE_CODE_VOID:
 388     case TYPE_CODE_ERROR:
 389     case TYPE_CODE_CHAR:
 390     case TYPE_CODE_BOOL:
 391     case TYPE_CODE_SET:
 392     case TYPE_CODE_RANGE:
 393     case TYPE_CODE_STRING:
 394     case TYPE_CODE_COMPLEX:
 395     case TYPE_CODE_TYPEDEF:
 396     case TYPE_CODE_FIXED_POINT:
 397       /* These types do not need a suffix.  They are listed so that
 398          gcc -Wall will report types that may not have been considered.  */
 399       break;
 400     default:
 401       gdb_assert_not_reached ("unexpected type");
 402       break;
 403     }
 404 }
 405
 406 /* See p-lang.h.  */
 407
 408 void
 409 pascal_language::type_print_base (struct type *type, struct ui_file *stream, int show,
 410                                   int level, const struct type_print_options *flags) const
 411 {
 412   int i;
 413   int len;
 414   LONGEST lastval;
 415   enum
 416     {
 417       s_none, s_public, s_private, s_protected
 418     }
 419   section_type;
 420
 421   QUIT;
 422   wrap_here ("    ");
 423   if (type == NULL)
 424     {
 425       fputs_styled ("<type unknown>", metadata_style.style (), stream);
 426       return;
 427     }
 428
 429   /* void pointer */
 430   if ((type->code () == TYPE_CODE_PTR)
 431       && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID))
 432     {
 433       fputs_filtered (type->name () ? type->name () : "pointer",
 434                       stream);
 435       return;
 436     }
 437   /* When SHOW is zero or less, and there is a valid type name, then always
 438      just print the type name directly from the type.  */
 439
 440   if (show <= 0
 441       && type->name () != NULL)
 442     {
 443       fputs_filtered (type->name (), stream);
 444       return;
 445     }
 446
 447   type = check_typedef (type);
 448
 449   switch (type->code ())
 450     {
 451     case TYPE_CODE_TYPEDEF:
 452     case TYPE_CODE_PTR:
 453     case TYPE_CODE_REF:
 454       type_print_base (TYPE_TARGET_TYPE (type), stream, show, level,
 455                        flags);
 456       break;
 457
 458     case TYPE_CODE_ARRAY:
 459       print_type (TYPE_TARGET_TYPE (type), NULL, stream, 0, 0, flags);
 460       break;
 461
 462     case TYPE_CODE_FUNC:
 463     case TYPE_CODE_METHOD:
 464       break;
 465     case TYPE_CODE_STRUCT:
 466       if (type->name () != NULL)
 467         {
 468           fputs_filtered (type->name (), stream);
 469           fputs_filtered (" = ", stream);
 470         }
 471       if (HAVE_CPLUS_STRUCT (type))
 472         {
 473           fprintf_filtered (stream, "class ");
 474         }
 475       else
 476         {
 477           fprintf_filtered (stream, "record ");
 478         }
 479       goto struct_union;
 480
 481     case TYPE_CODE_UNION:
 482       if (type->name () != NULL)
 483         {
 484           fputs_filtered (type->name (), stream);
 485           fputs_filtered (" = ", stream);
 486         }
 487       fprintf_filtered (stream, "case <?> of ");
 488
 489     struct_union:
 490       wrap_here ("    ");
 491       if (show < 0)
 492         {
 493           /* If we just printed a tag name, no need to print anything else.  */
 494           if (type->name () == NULL)
 495             fprintf_filtered (stream, "{...}");
 496         }
 497       else if (show > 0 || type->name () == NULL)
 498         {
 499           type_print_derivation_info (stream, type);
 500
 501           fprintf_filtered (stream, "\n");
 502           if ((type->num_fields () == 0) && (TYPE_NFN_FIELDS (type) == 0))
 503             {
 504               if (type->is_stub ())
 505                 fprintf_filtered (stream, "%*s<incomplete type>\n",
 506                                   level + 4, "");
 507               else
 508                 fprintf_filtered (stream, "%*s<no data fields>\n",
 509                                   level + 4, "");
 510             }
 511
 512           /* Start off with no specific section type, so we can print
 513              one for the first field we find, and use that section type
 514              thereafter until we find another type.  */
 515
 516           section_type = s_none;
 517
 518           /* If there is a base class for this type,
 519              do not print the field that it occupies.  */
 520
 521           len = type->num_fields ();
 522           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 523             {
 524               QUIT;
 525               /* Don't print out virtual function table.  */
 526               if ((startswith (TYPE_FIELD_NAME (type, i), "_vptr"))
 527                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 528                 continue;
 529
 530               /* If this is a pascal object or class we can print the
 531                  various section labels.  */
 532
 533               if (HAVE_CPLUS_STRUCT (type))
 534                 {
 535                   if (TYPE_FIELD_PROTECTED (type, i))
 536                     {
 537                       if (section_type != s_protected)
 538                         {
 539                           section_type = s_protected;
 540                           fprintf_filtered (stream, "%*sprotected\n",
 541                                             level + 2, "");
 542                         }
 543                     }
 544                   else if (TYPE_FIELD_PRIVATE (type, i))
 545                     {
 546                       if (section_type != s_private)
 547                         {
 548                           section_type = s_private;
 549                           fprintf_filtered (stream, "%*sprivate\n",
 550                                             level + 2, "");
 551                         }
 552                     }
 553                   else
 554                     {
 555                       if (section_type != s_public)
 556                         {
 557                           section_type = s_public;
 558                           fprintf_filtered (stream, "%*spublic\n",
 559                                             level + 2, "");
 560                         }
 561                     }
 562                 }
 563
 564               print_spaces_filtered (level + 4, stream);
 565               if (field_is_static (&type->field (i)))
 566                 fprintf_filtered (stream, "static ");
 567               print_type (type->field (i).type (),
 568                                  TYPE_FIELD_NAME (type, i),
 569                                  stream, show - 1, level + 4, flags);
 570               if (!field_is_static (&type->field (i))
 571                   && TYPE_FIELD_PACKED (type, i))
 572                 {
 573                   /* It is a bitfield.  This code does not attempt
 574                      to look at the bitpos and reconstruct filler,
 575                      unnamed fields.  This would lead to misleading
 576                      results if the compiler does not put out fields
 577                      for such things (I don't know what it does).  */
 578                   fprintf_filtered (stream, " : %d",
 579                                     TYPE_FIELD_BITSIZE (type, i));
 580                 }
 581               fprintf_filtered (stream, ";\n");
 582             }
 583
 584           /* If there are both fields and methods, put a space between.  */
 585           len = TYPE_NFN_FIELDS (type);
 586           if (len && section_type != s_none)
 587             fprintf_filtered (stream, "\n");
 588
 589           /* Object pascal: print out the methods.  */
 590
 591           for (i = 0; i < len; i++)
 592             {
 593               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 594               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 595               const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 596
 597               /* this is GNU C++ specific
 598                  how can we know constructor/destructor?
 599                  It might work for GNU pascal.  */
 600               for (j = 0; j < len2; j++)
 601                 {
 602                   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 603
 604                   int is_constructor = (startswith (physname, "__ct__"));
 605                   int is_destructor = (startswith (physname, "__dt__"));
 606
 607                   QUIT;
 608                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 609                     {
 610                       if (section_type != s_protected)
 611                         {
 612                           section_type = s_protected;
 613                           fprintf_filtered (stream, "%*sprotected\n",
 614                                             level + 2, "");
 615                         }
 616                     }
 617                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 618                     {
 619                       if (section_type != s_private)
 620                         {
 621                           section_type = s_private;
 622                           fprintf_filtered (stream, "%*sprivate\n",
 623                                             level + 2, "");
 624                         }
 625                     }
 626                   else
 627                     {
 628                       if (section_type != s_public)
 629                         {
 630                           section_type = s_public;
 631                           fprintf_filtered (stream, "%*spublic\n",
 632                                             level + 2, "");
 633                         }
 634                     }
 635
 636                   print_spaces_filtered (level + 4, stream);
 637                   if (TYPE_FN_FIELD_STATIC_P (f, j))
 638                     fprintf_filtered (stream, "static ");
 639                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 640                     {
 641                       /* Keep GDB from crashing here.  */
 642                       fprintf_filtered (stream, "<undefined type> %s;\n",
 643                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 644                       break;
 645                     }
 646
 647                   if (is_constructor)
 648                     {
 649                       fprintf_filtered (stream, "constructor ");
 650                     }
 651                   else if (is_destructor)
 652                     {
 653                       fprintf_filtered (stream, "destructor  ");
 654                     }
 655                   else if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0
 656                            && TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE(f, j))->code () != TYPE_CODE_VOID)
 657                     {
 658                       fprintf_filtered (stream, "function  ");
 659                     }
 660                   else
 661                     {
 662                       fprintf_filtered (stream, "procedure ");
 663                     }
 664                   /* This does not work, no idea why !!  */
 665
 666                   type_print_method_args (physname, method_name, stream);
 667
 668                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0
 669                       && TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE(f, j))->code () != TYPE_CODE_VOID)
 670                     {
 671                       fputs_filtered (" : ", stream);
 672                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 673                                   "", stream, -1);
 674                     }
 675                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 676                     fprintf_filtered (stream, "; virtual");
 677
 678                   fprintf_filtered (stream, ";\n");
 679                 }
 680             }
 681           fprintf_filtered (stream, "%*send", level, "");
 682         }
 683       break;
 684
 685     case TYPE_CODE_ENUM:
 686       if (type->name () != NULL)
 687         {
 688           fputs_filtered (type->name (), stream);
 689           if (show > 0)
 690             fputs_filtered (" ", stream);
 691         }
 692       /* enum is just defined by
 693          type enume_name = (enum_member1,enum_member2,...)  */
 694       fprintf_filtered (stream, " = ");
 695       wrap_here ("    ");
 696       if (show < 0)
 697         {
 698           /* If we just printed a tag name, no need to print anything else.  */
 699           if (type->name () == NULL)
 700             fprintf_filtered (stream, "(...)");
 701         }
 702       else if (show > 0 || type->name () == NULL)
 703         {
 704           fprintf_filtered (stream, "(");
 705           len = type->num_fields ();
 706           lastval = 0;
 707           for (i = 0; i < len; i++)
 708             {
 709               QUIT;
 710               if (i)
 711                 fprintf_filtered (stream, ", ");
 712               wrap_here ("    ");
 713               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 714               if (lastval != TYPE_FIELD_ENUMVAL (type, i))
 715                 {
 716                   fprintf_filtered (stream,
 717                                     " := %s",
 718                                     plongest (TYPE_FIELD_ENUMVAL (type, i)));
 719                   lastval = TYPE_FIELD_ENUMVAL (type, i);
 720                 }
 721               lastval++;
 722             }
 723           fprintf_filtered (stream, ")");
 724         }
 725       break;
 726
 727     case TYPE_CODE_VOID:
 728       fprintf_filtered (stream, "void");
 729       break;
 730
 731     case TYPE_CODE_UNDEF:
 732       fprintf_filtered (stream, "record <unknown>");
 733       break;
 734
 735     case TYPE_CODE_ERROR:
 736       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 737       break;
 738
 739       /* this probably does not work for enums.  */
 740     case TYPE_CODE_RANGE:
 741       {
 742         struct type *target = TYPE_TARGET_TYPE (type);
 743
 744         print_type_scalar (target, type->bounds ()->low.const_val (), stream);
 745         fputs_filtered ("..", stream);
 746         print_type_scalar (target, type->bounds ()->high.const_val (), stream);
 747       }
 748       break;
 749
 750     case TYPE_CODE_SET:
 751       fputs_filtered ("set of ", stream);
 752       print_type (type->index_type (), "", stream,
 753                          show - 1, level, flags);
 754       break;
 755
 756     case TYPE_CODE_STRING:
 757       fputs_filtered ("String", stream);
 758       break;
 759
 760     default:
 761       /* Handle types not explicitly handled by the other cases,
 762          such as fundamental types.  For these, just print whatever
 763          the type name is, as recorded in the type itself.  If there
 764          is no type name, then complain.  */
 765       if (type->name () != NULL)
 766         {
 767           fputs_filtered (type->name (), stream);
 768         }
 769       else
 770         {
 771           /* At least for dump_symtab, it is important that this not be
 772              an error ().  */
 773           fprintf_styled (stream, metadata_style.style (),
 774                           "<invalid unnamed pascal type code %d>",
 775                           type->code ());
 776         }
 777       break;
 778     }
 779 }