Commit | Line | Data |
---|---|---|
166606b7 PB |
1 | /* Support for printing Java types for GDB, the GNU debugger. |
2 | Copyright 1997 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 2 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, write to the Free Software | |
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
19 | ||
20 | ||
21 | #include "defs.h" | |
22 | #include "symtab.h" | |
23 | #include "gdbtypes.h" | |
d2e131a1 PB |
24 | #include "value.h" |
25 | #include "demangle.h" | |
26 | #include "jv-lang.h" | |
27 | #include "gdb_string.h" | |
28 | ||
29 | static void | |
30 | java_type_print_derivation_info (stream, type) | |
31 | GDB_FILE *stream; | |
32 | struct type *type; | |
33 | { | |
34 | char *name; | |
35 | int i = 0; | |
36 | int n_bases = TYPE_N_BASECLASSES (type); | |
37 | int prev = 0; | |
38 | ||
39 | for (i = 0; i < n_bases; i++) | |
40 | { | |
41 | int kind = BASETYPE_VIA_VIRTUAL(type, i) ? 'I' : 'E'; | |
42 | fputs_filtered (kind == prev ? ", " | |
43 | : kind == 'I' ? " implements " | |
44 | : " extends ", | |
45 | stream); | |
46 | prev = kind; | |
47 | name = type_name_no_tag (TYPE_BASECLASS (type, i)); | |
48 | fprintf_filtered (stream, "%s", name ? name : "(null)"); | |
49 | } | |
50 | if (i > 0) | |
51 | { | |
52 | fputs_filtered (" ", stream); | |
53 | } | |
54 | } | |
55 | ||
56 | /* Print the name of the type (or the ultimate pointer target, | |
57 | function value or array element), or the description of a | |
58 | structure or union. | |
59 | ||
60 | SHOW positive means print details about the type (e.g. enum values), | |
61 | and print structure elements passing SHOW - 1 for show. | |
62 | SHOW negative means just print the type name or struct tag if there is one. | |
63 | If there is no name, print something sensible but concise like | |
64 | "struct {...}". | |
65 | SHOW zero means just print the type name or struct tag if there is one. | |
66 | If there is no name, print something sensible but not as concise like | |
67 | "struct {int x; int y;}". | |
68 | ||
69 | LEVEL is the number of spaces to indent by. | |
70 | We increase it for some recursive calls. */ | |
71 | ||
72 | void | |
73 | java_type_print_base (type, stream, show, level) | |
74 | struct type *type; | |
75 | GDB_FILE *stream; | |
76 | int show; | |
77 | int level; | |
78 | { | |
79 | register int i; | |
80 | register int len; | |
81 | char *mangled_name; | |
82 | char *demangled_name; | |
83 | QUIT; | |
84 | ||
85 | wrap_here (" "); | |
86 | if (type == NULL) | |
87 | { | |
88 | fputs_filtered ("<type unknown>", stream); | |
89 | return; | |
90 | } | |
91 | ||
92 | /* When SHOW is zero or less, and there is a valid type name, then always | |
93 | just print the type name directly from the type. */ | |
94 | ||
95 | if (show <= 0 | |
96 | && TYPE_NAME (type) != NULL) | |
97 | { | |
98 | fputs_filtered (TYPE_NAME (type), stream); | |
99 | return; | |
100 | } | |
101 | ||
102 | CHECK_TYPEDEF (type); | |
103 | ||
104 | switch (TYPE_CODE (type)) | |
105 | { | |
106 | case TYPE_CODE_STRUCT: | |
107 | fprintf_filtered (stream, "class "); | |
108 | if (TYPE_TAG_NAME (type) != NULL) | |
109 | { | |
110 | fputs_filtered (TYPE_TAG_NAME (type), stream); | |
111 | if (show > 0) | |
112 | fputs_filtered (" ", stream); | |
113 | } | |
114 | wrap_here (" "); | |
115 | if (show < 0) | |
116 | { | |
117 | /* If we just printed a tag name, no need to print anything else. */ | |
118 | if (TYPE_TAG_NAME (type) == NULL) | |
119 | fprintf_filtered (stream, "{...}"); | |
120 | } | |
121 | else if (show > 0 || TYPE_TAG_NAME (type) == NULL) | |
122 | { | |
123 | java_type_print_derivation_info (stream, type); | |
124 | ||
125 | fprintf_filtered (stream, "{\n"); | |
126 | if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0)) | |
127 | { | |
128 | if (TYPE_FLAGS (type) & TYPE_FLAG_STUB) | |
129 | fprintfi_filtered (level + 4, stream, "<incomplete type>\n"); | |
130 | else | |
131 | fprintfi_filtered (level + 4, stream, "<no data fields>\n"); | |
132 | } | |
133 | ||
134 | /* If there is a base class for this type, | |
135 | do not print the field that it occupies. */ | |
136 | ||
137 | len = TYPE_NFIELDS (type); | |
138 | for (i = TYPE_N_BASECLASSES (type); i < len; i++) | |
139 | { | |
140 | QUIT; | |
141 | /* Don't print out virtual function table. */ | |
142 | if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5) | |
143 | && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5])) | |
144 | continue; | |
145 | ||
146 | /* If this is a C++ class we can print the various C++ section | |
147 | labels. */ | |
148 | ||
149 | print_spaces_filtered (level + 4, stream); | |
150 | if (HAVE_CPLUS_STRUCT (type)) | |
151 | { | |
152 | if (TYPE_FIELD_PROTECTED (type, i)) | |
153 | fprintf_filtered (stream, "protected "); | |
154 | else if (TYPE_FIELD_PRIVATE (type, i)) | |
155 | fprintf_filtered (stream, "private "); | |
156 | else | |
157 | fprintf_filtered (stream, "public "); | |
158 | } | |
159 | ||
160 | if (TYPE_FIELD_STATIC (type, i)) | |
161 | { | |
162 | fprintf_filtered (stream, "static "); | |
163 | } | |
164 | java_print_type (TYPE_FIELD_TYPE (type, i), | |
165 | TYPE_FIELD_NAME (type, i), | |
166 | stream, show - 1, level + 4); | |
167 | fprintf_filtered (stream, ";\n"); | |
168 | } | |
169 | ||
170 | /* If there are both fields and methods, put a space between. */ | |
171 | len = TYPE_NFN_FIELDS (type); | |
172 | if (len) | |
173 | fprintf_filtered (stream, "\n"); | |
174 | ||
175 | /* Print out the methods */ | |
176 | ||
177 | for (i = 0; i < len; i++) | |
178 | { | |
179 | struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); | |
180 | int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i); | |
181 | char *method_name = TYPE_FN_FIELDLIST_NAME (type, i); | |
182 | char *name = type_name_no_tag (type); | |
183 | int is_constructor = name && STREQ(method_name, name); | |
184 | for (j = 0; j < len2; j++) | |
185 | { | |
186 | char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); | |
187 | int is_full_physname_constructor = | |
188 | ((physname[0] == '_' && physname[1] == '_' | |
189 | && strchr ("0123456789Qt", physname[2])) | |
190 | || STREQN (physname, "__ct__", 6) | |
191 | || DESTRUCTOR_PREFIX_P (physname) | |
192 | || STREQN (physname, "__dt__", 6)); | |
193 | ||
194 | QUIT; | |
195 | print_spaces_filtered (level + 4, stream); | |
196 | if (TYPE_FN_FIELD_PROTECTED (f, j)) | |
197 | fprintf_filtered (stream, "protected "); | |
198 | else if (TYPE_FN_FIELD_PRIVATE (f, j)) | |
199 | fprintf_filtered (stream, "private "); | |
200 | else | |
201 | fprintf_filtered (stream, "public "); | |
202 | ||
203 | if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) | |
204 | fprintf_filtered (stream, "virtual "); | |
205 | else if (TYPE_FN_FIELD_STATIC_P (f, j)) | |
206 | fprintf_filtered (stream, "static "); | |
207 | if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0) | |
208 | { | |
209 | /* Keep GDB from crashing here. */ | |
210 | fprintf_filtered (stream, "<undefined type> %s;\n", | |
211 | TYPE_FN_FIELD_PHYSNAME (f, j)); | |
212 | break; | |
213 | } | |
214 | else if (!is_constructor && !is_full_physname_constructor) | |
215 | { | |
216 | type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), | |
217 | "", stream, -1); | |
218 | fputs_filtered (" ", stream); | |
219 | } | |
220 | if (TYPE_FN_FIELD_STUB (f, j)) | |
221 | /* Build something we can demangle. */ | |
222 | mangled_name = gdb_mangle_name (type, i, j); | |
223 | else | |
224 | mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j); | |
225 | ||
226 | demangled_name = | |
227 | cplus_demangle (mangled_name, | |
228 | DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA); | |
229 | if (demangled_name == NULL) | |
230 | fprintf_filtered (stream, "<badly mangled name '%s'>", | |
231 | mangled_name); | |
232 | else | |
233 | { | |
234 | char *demangled_no_class = demangled_name; | |
235 | char *ptr = demangled_name; | |
236 | for ( ; ; ) | |
237 | { | |
238 | char c = *ptr++; | |
239 | if (c == 0 || c == '(') | |
240 | break; | |
241 | if (c == '.') | |
242 | demangled_no_class = ptr; | |
243 | } | |
244 | fputs_filtered (demangled_no_class, stream); | |
245 | free (demangled_name); | |
246 | } | |
247 | ||
248 | if (TYPE_FN_FIELD_STUB (f, j)) | |
249 | free (mangled_name); | |
250 | ||
251 | fprintf_filtered (stream, ";\n"); | |
252 | } | |
253 | } | |
254 | ||
255 | fprintfi_filtered (level, stream, "}"); | |
256 | } | |
257 | break; | |
258 | ||
259 | default: | |
260 | c_type_print_base (type, stream, show, level); | |
261 | } | |
262 | } | |
166606b7 PB |
263 | |
264 | /* LEVEL is the depth to indent lines by. */ | |
265 | ||
266 | void | |
267 | java_print_type (type, varstring, stream, show, level) | |
268 | struct type *type; | |
269 | char *varstring; | |
270 | GDB_FILE *stream; | |
271 | int show; | |
272 | int level; | |
273 | { | |
d2e131a1 PB |
274 | java_type_print_base (type, stream, show, level); |
275 | ||
276 | if (varstring != NULL && *varstring != '\0') | |
277 | { | |
278 | fputs_filtered (" ", stream); | |
279 | fputs_filtered (varstring, stream); | |
280 | } | |
281 | #if 0 | |
282 | /* For demangled function names, we have the arglist as part of the name, | |
283 | so don't print an additional pair of ()'s */ | |
284 | ||
285 | demangled_args = strchr(varstring, '(') != NULL; | |
286 | c_type_print_varspec_suffix (type, stream, show, 0, demangled_args); | |
287 | #endif | |
166606b7 | 288 | } |