gdb/jv-typeprint.c

   1 /* Support for printing Java types for GDB, the GNU debugger.
   2    Copyright (C) 1997-2016 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
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "value.h"
  24 #include "demangle.h"
  25 #include "gdb-demangle.h"
  26 #include "jv-lang.h"
  27 #include "typeprint.h"
  28 #include "c-lang.h"
  29 #include "cp-abi.h"
  30 #include "cp-support.h"
  31
  32 /* Local functions */
  33
  34 static void java_type_print_base (struct type * type,
  35                                   struct ui_file *stream, int show,
  36                                   int level,
  37                                   const struct type_print_options *flags);
  38
  39 static void
  40 java_type_print_derivation_info (struct ui_file *stream, struct type *type)
  41 {
  42   const char *name;
  43   int i;
  44   int n_bases;
  45   int prev;
  46
  47   n_bases = TYPE_N_BASECLASSES (type);
  48
  49   for (i = 0, prev = 0; i < n_bases; i++)
  50     {
  51       int kind;
  52
  53       kind = BASETYPE_VIA_VIRTUAL (type, i) ? 'I' : 'E';
  54
  55       fputs_filtered (kind == prev ? ", "
  56                       : kind == 'I' ? " implements "
  57                       : " extends ",
  58                       stream);
  59       prev = kind;
  60       name = type_name_no_tag (TYPE_BASECLASS (type, i));
  61
  62       fprintf_filtered (stream, "%s", name ? name : "(null)");
  63     }
  64
  65   if (i > 0)
  66     fputs_filtered (" ", stream);
  67 }
  68
  69 /* Print the name of the type (or the ultimate pointer target,
  70    function value or array element), or the description of a
  71    structure or union.
  72
  73    SHOW positive means print details about the type (e.g. enum values),
  74    and print structure elements passing SHOW - 1 for show.
  75    SHOW negative means just print the type name or struct tag if there is one.
  76    If there is no name, print something sensible but concise like
  77    "struct {...}".
  78    SHOW zero means just print the type name or struct tag if there is one.
  79    If there is no name, print something sensible but not as concise like
  80    "struct {int x; int y;}".
  81
  82    LEVEL is the number of spaces to indent by.
  83    We increase it for some recursive calls.  */
  84
  85 static void
  86 java_type_print_base (struct type *type, struct ui_file *stream, int show,
  87                       int level, const struct type_print_options *flags)
  88 {
  89   int i;
  90   int len;
  91   char *mangled_name;
  92   char *demangled_name;
  93
  94   QUIT;
  95   wrap_here ("    ");
  96
  97   if (type == NULL)
  98     {
  99       fputs_filtered ("<type unknown>", stream);
 100       return;
 101     }
 102
 103   /* When SHOW is zero or less, and there is a valid type name, then always
 104      just print the type name directly from the type.  */
 105
 106   if (show <= 0
 107       && TYPE_NAME (type) != NULL)
 108     {
 109       fputs_filtered (TYPE_NAME (type), stream);
 110       return;
 111     }
 112
 113   type = check_typedef (type);
 114
 115   switch (TYPE_CODE (type))
 116     {
 117     case TYPE_CODE_PTR:
 118       java_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level,
 119                             flags);
 120       break;
 121
 122     case TYPE_CODE_STRUCT:
 123       if (TYPE_TAG_NAME (type) != NULL && TYPE_TAG_NAME (type)[0] == '[')
 124         {                       /* array type */
 125           char *name = java_demangle_type_signature (TYPE_TAG_NAME (type));
 126
 127           fputs_filtered (name, stream);
 128           xfree (name);
 129           break;
 130         }
 131
 132       if (show >= 0)
 133         fprintf_filtered (stream, "class ");
 134
 135       if (TYPE_TAG_NAME (type) != NULL)
 136         {
 137           fputs_filtered (TYPE_TAG_NAME (type), stream);
 138           if (show > 0)
 139             fputs_filtered (" ", stream);
 140         }
 141
 142       wrap_here ("    ");
 143
 144       if (show < 0)
 145         {
 146           /* If we just printed a tag name, no need to print anything else.  */
 147           if (TYPE_TAG_NAME (type) == NULL)
 148             fprintf_filtered (stream, "{...}");
 149         }
 150       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 151         {
 152           java_type_print_derivation_info (stream, type);
 153
 154           fprintf_filtered (stream, "{\n");
 155           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 156             {
 157               if (TYPE_STUB (type))
 158                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 159               else
 160                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 161             }
 162
 163           /* If there is a base class for this type,
 164              do not print the field that it occupies.  */
 165
 166           len = TYPE_NFIELDS (type);
 167           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 168             {
 169               QUIT;
 170               /* Don't print out virtual function table.  */
 171               if (startswith (TYPE_FIELD_NAME (type, i), "_vptr")
 172                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 173                 continue;
 174
 175               /* Don't print the dummy field "class".  */
 176               if (startswith (TYPE_FIELD_NAME (type, i), "class"))
 177                 continue;
 178
 179               print_spaces_filtered (level + 4, stream);
 180
 181               if (HAVE_CPLUS_STRUCT (type))
 182                 {
 183                   if (TYPE_FIELD_PROTECTED (type, i))
 184                     fprintf_filtered (stream, "protected ");
 185                   else if (TYPE_FIELD_PRIVATE (type, i))
 186                     fprintf_filtered (stream, "private ");
 187                   else
 188                     fprintf_filtered (stream, "public ");
 189                 }
 190
 191               if (field_is_static (&TYPE_FIELD (type, i)))
 192                 fprintf_filtered (stream, "static ");
 193
 194               java_print_type (TYPE_FIELD_TYPE (type, i),
 195                                TYPE_FIELD_NAME (type, i),
 196                                stream, show - 1, level + 4, flags);
 197
 198               fprintf_filtered (stream, ";\n");
 199             }
 200
 201           /* If there are both fields and methods, put a space between.  */
 202           len = TYPE_NFN_FIELDS (type);
 203           if (len)
 204             fprintf_filtered (stream, "\n");
 205
 206           /* Print out the methods.  */
 207
 208           for (i = 0; i < len; i++)
 209             {
 210               struct fn_field *f;
 211               int j;
 212               const char *method_name;
 213               const char *name;
 214               int is_constructor;
 215               int n_overloads;
 216
 217               f = TYPE_FN_FIELDLIST1 (type, i);
 218               n_overloads = TYPE_FN_FIELDLIST_LENGTH (type, i);
 219               method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 220               name = type_name_no_tag (type);
 221               is_constructor = name && strcmp (method_name, name) == 0;
 222
 223               for (j = 0; j < n_overloads; j++)
 224                 {
 225                   const char *real_physname;
 226                   const char *p;
 227                   char *physname;
 228                   int is_full_physname_constructor;
 229
 230                   real_physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 231
 232                   /* The physname will contain the return type
 233                      after the final closing parenthesis.  Strip it off.  */
 234                   p = strrchr (real_physname, ')');
 235                   gdb_assert (p != NULL);
 236                   ++p;   /* Keep the trailing ')'.  */
 237                   physname = (char *) alloca (p - real_physname + 1);
 238                   memcpy (physname, real_physname, p - real_physname);
 239                   physname[p - real_physname] = '\0';
 240
 241                   is_full_physname_constructor
 242                     = (TYPE_FN_FIELD_CONSTRUCTOR (f, j)
 243                        || is_constructor_name (physname)
 244                        || is_destructor_name (physname));
 245
 246                   QUIT;
 247
 248                   print_spaces_filtered (level + 4, stream);
 249
 250                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 251                     fprintf_filtered (stream, "protected ");
 252                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 253                     fprintf_filtered (stream, "private ");
 254                   else if (TYPE_FN_FIELD_PUBLIC (f, j))
 255                     fprintf_filtered (stream, "public ");
 256
 257                   if (TYPE_FN_FIELD_ABSTRACT (f, j))
 258                     fprintf_filtered (stream, "abstract ");
 259                   if (TYPE_FN_FIELD_STATIC (f, j))
 260                     fprintf_filtered (stream, "static ");
 261                   if (TYPE_FN_FIELD_FINAL (f, j))
 262                     fprintf_filtered (stream, "final ");
 263                   if (TYPE_FN_FIELD_SYNCHRONIZED (f, j))
 264                     fprintf_filtered (stream, "synchronized ");
 265                   if (TYPE_FN_FIELD_NATIVE (f, j))
 266                     fprintf_filtered (stream, "native ");
 267
 268                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 269                     {
 270                       /* Keep GDB from crashing here.  */
 271                       fprintf_filtered (stream, "<undefined type> %s;\n",
 272                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 273                       break;
 274                     }
 275                   else if (!is_constructor && !is_full_physname_constructor)
 276                     {
 277                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 278                                   "", stream, -1);
 279                       fputs_filtered (" ", stream);
 280                     }
 281
 282                   if (TYPE_FN_FIELD_STUB (f, j))
 283                     /* Build something we can demangle.  */
 284                     mangled_name = gdb_mangle_name (type, i, j);
 285                   else
 286                     mangled_name = physname;
 287
 288                   demangled_name =
 289                     gdb_demangle (mangled_name,
 290                                   DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
 291
 292                   if (demangled_name == NULL)
 293                     demangled_name = xstrdup (mangled_name);
 294
 295                   {
 296                     char *demangled_no_class;
 297                     char *ptr;
 298
 299                     ptr = demangled_no_class = demangled_name;
 300
 301                     while (1)
 302                       {
 303                         char c;
 304
 305                         c = *ptr++;
 306
 307                         if (c == 0 || c == '(')
 308                           break;
 309                         if (c == '.')
 310                           demangled_no_class = ptr;
 311                       }
 312
 313                     fputs_filtered (demangled_no_class, stream);
 314                     xfree (demangled_name);
 315                   }
 316
 317                   if (TYPE_FN_FIELD_STUB (f, j))
 318                     xfree (mangled_name);
 319
 320                   fprintf_filtered (stream, ";\n");
 321                 }
 322             }
 323
 324           fprintfi_filtered (level, stream, "}");
 325         }
 326       break;
 327
 328     default:
 329       c_type_print_base (type, stream, show, level, flags);
 330     }
 331 }
 332
 333 /* LEVEL is the depth to indent lines by.  */
 334
 335 void
 336 java_print_type (struct type *type, const char *varstring,
 337                  struct ui_file *stream, int show, int level,
 338                  const struct type_print_options *flags)
 339 {
 340   int demangled_args;
 341
 342   java_type_print_base (type, stream, show, level, flags);
 343
 344   if (varstring != NULL && *varstring != '\0')
 345     {
 346       fputs_filtered (" ", stream);
 347       fputs_filtered (varstring, stream);
 348     }
 349
 350   /* For demangled function names, we have the arglist as part of the name,
 351      so don't print an additional pair of ()'s.  */
 352
 353   demangled_args = varstring != NULL && strchr (varstring, '(') != NULL;
 354   c_type_print_varspec_suffix (type, stream, show, 0, demangled_args, flags);
 355 }