1 /* Support for printing Java types for GDB, the GNU debugger. 2 Copyright (C) 1997-2013 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 "gdb_string.h" 28 #include "typeprint.h" 29 #include "c-lang.h" 30 #include "cp-abi.h" 31 #include "gdb_assert.h" 32 33 /* Local functions */ 34 35 static void java_type_print_base (struct type * type, 36 struct ui_file *stream, int show, 37 int level, 38 const struct type_print_options *flags); 39 40 static void 41 java_type_print_derivation_info (struct ui_file *stream, struct type *type) 42 { 43 const char *name; 44 int i; 45 int n_bases; 46 int prev; 47 48 n_bases = TYPE_N_BASECLASSES (type); 49 50 for (i = 0, prev = 0; i < n_bases; i++) 51 { 52 int kind; 53 54 kind = BASETYPE_VIA_VIRTUAL (type, i) ? 'I' : 'E'; 55 56 fputs_filtered (kind == prev ? ", " 57 : kind == 'I' ? " implements " 58 : " extends ", 59 stream); 60 prev = kind; 61 name = type_name_no_tag (TYPE_BASECLASS (type, i)); 62 63 fprintf_filtered (stream, "%s", name ? name : "(null)"); 64 } 65 66 if (i > 0) 67 fputs_filtered (" ", stream); 68 } 69 70 /* Print the name of the type (or the ultimate pointer target, 71 function value or array element), or the description of a 72 structure or union. 73 74 SHOW positive means print details about the type (e.g. enum values), 75 and print structure elements passing SHOW - 1 for show. 76 SHOW negative means just print the type name or struct tag if there is one. 77 If there is no name, print something sensible but concise like 78 "struct {...}". 79 SHOW zero means just print the type name or struct tag if there is one. 80 If there is no name, print something sensible but not as concise like 81 "struct {int x; int y;}". 82 83 LEVEL is the number of spaces to indent by. 84 We increase it for some recursive calls. */ 85 86 static void 87 java_type_print_base (struct type *type, struct ui_file *stream, int show, 88 int level, const struct type_print_options *flags) 89 { 90 int i; 91 int len; 92 char *mangled_name; 93 char *demangled_name; 94 95 QUIT; 96 wrap_here (" "); 97 98 if (type == NULL) 99 { 100 fputs_filtered ("<type unknown>", stream); 101 return; 102 } 103 104 /* When SHOW is zero or less, and there is a valid type name, then always 105 just print the type name directly from the type. */ 106 107 if (show <= 0 108 && TYPE_NAME (type) != NULL) 109 { 110 fputs_filtered (TYPE_NAME (type), stream); 111 return; 112 } 113 114 CHECK_TYPEDEF (type); 115 116 switch (TYPE_CODE (type)) 117 { 118 case TYPE_CODE_PTR: 119 java_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level, 120 flags); 121 break; 122 123 case TYPE_CODE_STRUCT: 124 if (TYPE_TAG_NAME (type) != NULL && TYPE_TAG_NAME (type)[0] == '[') 125 { /* array type */ 126 char *name = java_demangle_type_signature (TYPE_TAG_NAME (type)); 127 128 fputs_filtered (name, stream); 129 xfree (name); 130 break; 131 } 132 133 if (show >= 0) 134 fprintf_filtered (stream, "class "); 135 136 if (TYPE_TAG_NAME (type) != NULL) 137 { 138 fputs_filtered (TYPE_TAG_NAME (type), stream); 139 if (show > 0) 140 fputs_filtered (" ", stream); 141 } 142 143 wrap_here (" "); 144 145 if (show < 0) 146 { 147 /* If we just printed a tag name, no need to print anything else. */ 148 if (TYPE_TAG_NAME (type) == NULL) 149 fprintf_filtered (stream, "{...}"); 150 } 151 else if (show > 0 || TYPE_TAG_NAME (type) == NULL) 152 { 153 java_type_print_derivation_info (stream, type); 154 155 fprintf_filtered (stream, "{\n"); 156 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0)) 157 { 158 if (TYPE_STUB (type)) 159 fprintfi_filtered (level + 4, stream, "<incomplete type>\n"); 160 else 161 fprintfi_filtered (level + 4, stream, "<no data fields>\n"); 162 } 163 164 /* If there is a base class for this type, 165 do not print the field that it occupies. */ 166 167 len = TYPE_NFIELDS (type); 168 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 169 { 170 QUIT; 171 /* Don't print out virtual function table. */ 172 if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0 173 && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5])) 174 continue; 175 176 /* Don't print the dummy field "class". */ 177 if (strncmp (TYPE_FIELD_NAME (type, i), "class", 5) == 0) 178 continue; 179 180 print_spaces_filtered (level + 4, stream); 181 182 if (HAVE_CPLUS_STRUCT (type)) 183 { 184 if (TYPE_FIELD_PROTECTED (type, i)) 185 fprintf_filtered (stream, "protected "); 186 else if (TYPE_FIELD_PRIVATE (type, i)) 187 fprintf_filtered (stream, "private "); 188 else 189 fprintf_filtered (stream, "public "); 190 } 191 192 if (field_is_static (&TYPE_FIELD (type, i))) 193 fprintf_filtered (stream, "static "); 194 195 java_print_type (TYPE_FIELD_TYPE (type, i), 196 TYPE_FIELD_NAME (type, i), 197 stream, show - 1, level + 4, flags); 198 199 fprintf_filtered (stream, ";\n"); 200 } 201 202 /* If there are both fields and methods, put a space between. */ 203 len = TYPE_NFN_FIELDS (type); 204 if (len) 205 fprintf_filtered (stream, "\n"); 206 207 /* Print out the methods. */ 208 209 for (i = 0; i < len; i++) 210 { 211 struct fn_field *f; 212 int j; 213 const char *method_name; 214 const char *name; 215 int is_constructor; 216 int n_overloads; 217 218 f = TYPE_FN_FIELDLIST1 (type, i); 219 n_overloads = TYPE_FN_FIELDLIST_LENGTH (type, i); 220 method_name = TYPE_FN_FIELDLIST_NAME (type, i); 221 name = type_name_no_tag (type); 222 is_constructor = name && strcmp (method_name, name) == 0; 223 224 for (j = 0; j < n_overloads; j++) 225 { 226 const char *real_physname; 227 char *physname, *p; 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 = 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 cplus_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 } 356