Commit | Line | Data |
---|---|---|
99ad9427 YQ |
1 | /* varobj support for C and C++. |
2 | ||
32d0add0 | 3 | Copyright (C) 1999-2015 Free Software Foundation, Inc. |
99ad9427 YQ |
4 | |
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 3 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
17 | ||
18 | #include "defs.h" | |
19 | #include "value.h" | |
20 | #include "varobj.h" | |
21 | #include "gdbthread.h" | |
22 | #include "valprint.h" | |
23 | ||
24 | static void cplus_class_num_children (struct type *type, int children[3]); | |
25 | ||
26 | /* The names of varobjs representing anonymous structs or unions. */ | |
27 | #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>") | |
28 | #define ANONYMOUS_UNION_NAME _("<anonymous union>") | |
29 | ||
30 | /* Does CHILD represent a child with no name? This happens when | |
31 | the child is an anonmous struct or union and it has no field name | |
32 | in its parent variable. | |
33 | ||
34 | This has already been determined by *_describe_child. The easiest | |
35 | thing to do is to compare the child's name with ANONYMOUS_*_NAME. */ | |
36 | ||
37 | int | |
b09e2c59 | 38 | varobj_is_anonymous_child (const struct varobj *child) |
99ad9427 YQ |
39 | { |
40 | return (strcmp (child->name, ANONYMOUS_STRUCT_NAME) == 0 | |
41 | || strcmp (child->name, ANONYMOUS_UNION_NAME) == 0); | |
42 | } | |
43 | ||
44 | /* Given the value and the type of a variable object, | |
45 | adjust the value and type to those necessary | |
46 | for getting children of the variable object. | |
47 | This includes dereferencing top-level references | |
48 | to all types and dereferencing pointers to | |
49 | structures. | |
50 | ||
51 | If LOOKUP_ACTUAL_TYPE is set the enclosing type of the | |
52 | value will be fetched and if it differs from static type | |
53 | the value will be casted to it. | |
54 | ||
55 | Both TYPE and *TYPE should be non-null. VALUE | |
56 | can be null if we want to only translate type. | |
57 | *VALUE can be null as well -- if the parent | |
58 | value is not known. | |
59 | ||
60 | If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1 | |
61 | depending on whether pointer was dereferenced | |
62 | in this function. */ | |
63 | ||
64 | static void | |
65 | adjust_value_for_child_access (struct value **value, | |
66 | struct type **type, | |
67 | int *was_ptr, | |
68 | int lookup_actual_type) | |
69 | { | |
70 | gdb_assert (type && *type); | |
71 | ||
72 | if (was_ptr) | |
73 | *was_ptr = 0; | |
74 | ||
75 | *type = check_typedef (*type); | |
76 | ||
77 | /* The type of value stored in varobj, that is passed | |
78 | to us, is already supposed to be | |
79 | reference-stripped. */ | |
80 | ||
81 | gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF); | |
82 | ||
83 | /* Pointers to structures are treated just like | |
84 | structures when accessing children. Don't | |
85 | dererences pointers to other types. */ | |
86 | if (TYPE_CODE (*type) == TYPE_CODE_PTR) | |
87 | { | |
88 | struct type *target_type = get_target_type (*type); | |
89 | if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT | |
90 | || TYPE_CODE (target_type) == TYPE_CODE_UNION) | |
91 | { | |
92 | if (value && *value) | |
93 | { | |
99ad9427 | 94 | |
492d29ea | 95 | TRY |
99ad9427 YQ |
96 | { |
97 | *value = value_ind (*value); | |
98 | } | |
99 | ||
492d29ea PA |
100 | CATCH (except, RETURN_MASK_ERROR) |
101 | { | |
102 | *value = NULL; | |
103 | } | |
104 | END_CATCH | |
99ad9427 YQ |
105 | } |
106 | *type = target_type; | |
107 | if (was_ptr) | |
108 | *was_ptr = 1; | |
109 | } | |
110 | } | |
111 | ||
112 | /* The 'get_target_type' function calls check_typedef on | |
113 | result, so we can immediately check type code. No | |
114 | need to call check_typedef here. */ | |
115 | ||
116 | /* Access a real type of the value (if necessary and possible). */ | |
117 | if (value && *value && lookup_actual_type) | |
118 | { | |
119 | struct type *enclosing_type; | |
120 | int real_type_found = 0; | |
121 | ||
122 | enclosing_type = value_actual_type (*value, 1, &real_type_found); | |
123 | if (real_type_found) | |
124 | { | |
125 | *type = enclosing_type; | |
126 | *value = value_cast (enclosing_type, *value); | |
127 | } | |
128 | } | |
129 | } | |
130 | ||
9a9a7608 AB |
131 | /* Is VAR a path expression parent, i.e., can it be used to construct |
132 | a valid path expression? */ | |
133 | ||
134 | static int | |
b09e2c59 | 135 | c_is_path_expr_parent (const struct varobj *var) |
9a9a7608 AB |
136 | { |
137 | struct type *type; | |
138 | ||
139 | /* "Fake" children are not path_expr parents. */ | |
140 | if (CPLUS_FAKE_CHILD (var)) | |
141 | return 0; | |
142 | ||
143 | type = varobj_get_gdb_type (var); | |
144 | ||
145 | /* Anonymous unions and structs are also not path_expr parents. */ | |
146 | if ((TYPE_CODE (type) == TYPE_CODE_STRUCT | |
147 | || TYPE_CODE (type) == TYPE_CODE_UNION) | |
148 | && TYPE_NAME (type) == NULL | |
149 | && TYPE_TAG_NAME (type) == NULL) | |
150 | { | |
c1cc6152 | 151 | const struct varobj *parent = var->parent; |
9a9a7608 AB |
152 | |
153 | while (parent != NULL && CPLUS_FAKE_CHILD (parent)) | |
154 | parent = parent->parent; | |
155 | ||
156 | if (parent != NULL) | |
157 | { | |
158 | struct type *parent_type; | |
159 | int was_ptr; | |
160 | ||
161 | parent_type = varobj_get_value_type (parent); | |
162 | adjust_value_for_child_access (NULL, &parent_type, &was_ptr, 0); | |
163 | ||
164 | if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT | |
165 | || TYPE_CODE (parent_type) == TYPE_CODE_UNION) | |
166 | { | |
167 | const char *field_name; | |
168 | ||
169 | gdb_assert (var->index < TYPE_NFIELDS (parent_type)); | |
170 | field_name = TYPE_FIELD_NAME (parent_type, var->index); | |
171 | return !(field_name == NULL || *field_name == '\0'); | |
172 | } | |
173 | } | |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
178 | return 1; | |
179 | } | |
180 | ||
99ad9427 YQ |
181 | /* C */ |
182 | ||
183 | static int | |
b09e2c59 | 184 | c_number_of_children (const struct varobj *var) |
99ad9427 YQ |
185 | { |
186 | struct type *type = varobj_get_value_type (var); | |
187 | int children = 0; | |
188 | struct type *target; | |
189 | ||
190 | adjust_value_for_child_access (NULL, &type, NULL, 0); | |
191 | target = get_target_type (type); | |
192 | ||
193 | switch (TYPE_CODE (type)) | |
194 | { | |
195 | case TYPE_CODE_ARRAY: | |
196 | if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0 | |
197 | && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)) | |
198 | children = TYPE_LENGTH (type) / TYPE_LENGTH (target); | |
199 | else | |
200 | /* If we don't know how many elements there are, don't display | |
201 | any. */ | |
202 | children = 0; | |
203 | break; | |
204 | ||
205 | case TYPE_CODE_STRUCT: | |
206 | case TYPE_CODE_UNION: | |
207 | children = TYPE_NFIELDS (type); | |
208 | break; | |
209 | ||
210 | case TYPE_CODE_PTR: | |
211 | /* The type here is a pointer to non-struct. Typically, pointers | |
212 | have one child, except for function ptrs, which have no children, | |
213 | and except for void*, as we don't know what to show. | |
214 | ||
215 | We can show char* so we allow it to be dereferenced. If you decide | |
216 | to test for it, please mind that a little magic is necessary to | |
217 | properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and | |
218 | TYPE_NAME == "char". */ | |
219 | if (TYPE_CODE (target) == TYPE_CODE_FUNC | |
220 | || TYPE_CODE (target) == TYPE_CODE_VOID) | |
221 | children = 0; | |
222 | else | |
223 | children = 1; | |
224 | break; | |
225 | ||
226 | default: | |
227 | /* Other types have no children. */ | |
228 | break; | |
229 | } | |
230 | ||
231 | return children; | |
232 | } | |
233 | ||
234 | static char * | |
b09e2c59 | 235 | c_name_of_variable (const struct varobj *parent) |
99ad9427 YQ |
236 | { |
237 | return xstrdup (parent->name); | |
238 | } | |
239 | ||
240 | /* Return the value of element TYPE_INDEX of a structure | |
241 | value VALUE. VALUE's type should be a structure, | |
242 | or union, or a typedef to struct/union. | |
243 | ||
244 | Returns NULL if getting the value fails. Never throws. */ | |
245 | ||
246 | static struct value * | |
247 | value_struct_element_index (struct value *value, int type_index) | |
248 | { | |
249 | struct value *result = NULL; | |
99ad9427 YQ |
250 | struct type *type = value_type (value); |
251 | ||
252 | type = check_typedef (type); | |
253 | ||
254 | gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT | |
255 | || TYPE_CODE (type) == TYPE_CODE_UNION); | |
256 | ||
492d29ea | 257 | TRY |
99ad9427 YQ |
258 | { |
259 | if (field_is_static (&TYPE_FIELD (type, type_index))) | |
260 | result = value_static_field (type, type_index); | |
261 | else | |
262 | result = value_primitive_field (value, 0, type_index, type); | |
263 | } | |
492d29ea | 264 | CATCH (e, RETURN_MASK_ERROR) |
99ad9427 YQ |
265 | { |
266 | return NULL; | |
267 | } | |
492d29ea PA |
268 | END_CATCH |
269 | ||
270 | return result; | |
99ad9427 YQ |
271 | } |
272 | ||
273 | /* Obtain the information about child INDEX of the variable | |
274 | object PARENT. | |
275 | If CNAME is not null, sets *CNAME to the name of the child relative | |
276 | to the parent. | |
277 | If CVALUE is not null, sets *CVALUE to the value of the child. | |
278 | If CTYPE is not null, sets *CTYPE to the type of the child. | |
279 | ||
280 | If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding | |
281 | information cannot be determined, set *CNAME, *CVALUE, or *CTYPE | |
282 | to NULL. */ | |
283 | ||
284 | static void | |
c1cc6152 | 285 | c_describe_child (const struct varobj *parent, int index, |
99ad9427 YQ |
286 | char **cname, struct value **cvalue, struct type **ctype, |
287 | char **cfull_expression) | |
288 | { | |
289 | struct value *value = parent->value; | |
290 | struct type *type = varobj_get_value_type (parent); | |
291 | char *parent_expression = NULL; | |
292 | int was_ptr; | |
99ad9427 YQ |
293 | |
294 | if (cname) | |
295 | *cname = NULL; | |
296 | if (cvalue) | |
297 | *cvalue = NULL; | |
298 | if (ctype) | |
299 | *ctype = NULL; | |
300 | if (cfull_expression) | |
301 | { | |
302 | *cfull_expression = NULL; | |
303 | parent_expression | |
304 | = varobj_get_path_expr (varobj_get_path_expr_parent (parent)); | |
305 | } | |
306 | adjust_value_for_child_access (&value, &type, &was_ptr, 0); | |
307 | ||
308 | switch (TYPE_CODE (type)) | |
309 | { | |
310 | case TYPE_CODE_ARRAY: | |
311 | if (cname) | |
312 | *cname | |
313 | = xstrdup (int_string (index | |
314 | + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)), | |
315 | 10, 1, 0, 0)); | |
316 | ||
317 | if (cvalue && value) | |
318 | { | |
319 | int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)); | |
320 | ||
492d29ea | 321 | TRY |
99ad9427 YQ |
322 | { |
323 | *cvalue = value_subscript (value, real_index); | |
324 | } | |
492d29ea PA |
325 | CATCH (except, RETURN_MASK_ERROR) |
326 | { | |
327 | } | |
328 | END_CATCH | |
99ad9427 YQ |
329 | } |
330 | ||
331 | if (ctype) | |
332 | *ctype = get_target_type (type); | |
333 | ||
334 | if (cfull_expression) | |
335 | *cfull_expression = | |
336 | xstrprintf ("(%s)[%s]", parent_expression, | |
337 | int_string (index | |
338 | + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)), | |
339 | 10, 1, 0, 0)); | |
340 | ||
341 | ||
342 | break; | |
343 | ||
344 | case TYPE_CODE_STRUCT: | |
345 | case TYPE_CODE_UNION: | |
346 | { | |
347 | const char *field_name; | |
348 | ||
349 | /* If the type is anonymous and the field has no name, | |
350 | set an appropriate name. */ | |
351 | field_name = TYPE_FIELD_NAME (type, index); | |
352 | if (field_name == NULL || *field_name == '\0') | |
353 | { | |
354 | if (cname) | |
355 | { | |
356 | if (TYPE_CODE (TYPE_FIELD_TYPE (type, index)) | |
357 | == TYPE_CODE_STRUCT) | |
358 | *cname = xstrdup (ANONYMOUS_STRUCT_NAME); | |
359 | else | |
360 | *cname = xstrdup (ANONYMOUS_UNION_NAME); | |
361 | } | |
362 | ||
363 | if (cfull_expression) | |
364 | *cfull_expression = xstrdup (""); | |
365 | } | |
366 | else | |
367 | { | |
368 | if (cname) | |
369 | *cname = xstrdup (field_name); | |
370 | ||
371 | if (cfull_expression) | |
372 | { | |
373 | char *join = was_ptr ? "->" : "."; | |
374 | ||
375 | *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, | |
376 | join, field_name); | |
377 | } | |
378 | } | |
379 | ||
380 | if (cvalue && value) | |
381 | { | |
382 | /* For C, varobj index is the same as type index. */ | |
383 | *cvalue = value_struct_element_index (value, index); | |
384 | } | |
385 | ||
386 | if (ctype) | |
387 | *ctype = TYPE_FIELD_TYPE (type, index); | |
388 | } | |
389 | break; | |
390 | ||
391 | case TYPE_CODE_PTR: | |
392 | if (cname) | |
393 | *cname = xstrprintf ("*%s", parent->name); | |
394 | ||
395 | if (cvalue && value) | |
396 | { | |
492d29ea | 397 | TRY |
99ad9427 YQ |
398 | { |
399 | *cvalue = value_ind (value); | |
400 | } | |
401 | ||
492d29ea PA |
402 | CATCH (except, RETURN_MASK_ERROR) |
403 | { | |
404 | *cvalue = NULL; | |
405 | } | |
406 | END_CATCH | |
99ad9427 YQ |
407 | } |
408 | ||
409 | /* Don't use get_target_type because it calls | |
410 | check_typedef and here, we want to show the true | |
411 | declared type of the variable. */ | |
412 | if (ctype) | |
413 | *ctype = TYPE_TARGET_TYPE (type); | |
414 | ||
415 | if (cfull_expression) | |
416 | *cfull_expression = xstrprintf ("*(%s)", parent_expression); | |
417 | ||
418 | break; | |
419 | ||
420 | default: | |
421 | /* This should not happen. */ | |
422 | if (cname) | |
423 | *cname = xstrdup ("???"); | |
424 | if (cfull_expression) | |
425 | *cfull_expression = xstrdup ("???"); | |
426 | /* Don't set value and type, we don't know then. */ | |
427 | } | |
428 | } | |
429 | ||
430 | static char * | |
c1cc6152 | 431 | c_name_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
432 | { |
433 | char *name; | |
434 | ||
435 | c_describe_child (parent, index, &name, NULL, NULL, NULL); | |
436 | return name; | |
437 | } | |
438 | ||
439 | static char * | |
b09e2c59 | 440 | c_path_expr_of_child (const struct varobj *child) |
99ad9427 | 441 | { |
2568868e SM |
442 | char *path_expr; |
443 | ||
99ad9427 | 444 | c_describe_child (child->parent, child->index, NULL, NULL, NULL, |
2568868e SM |
445 | &path_expr); |
446 | return path_expr; | |
99ad9427 YQ |
447 | } |
448 | ||
449 | static struct value * | |
c1cc6152 | 450 | c_value_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
451 | { |
452 | struct value *value = NULL; | |
453 | ||
454 | c_describe_child (parent, index, NULL, &value, NULL, NULL); | |
455 | return value; | |
456 | } | |
457 | ||
458 | static struct type * | |
c1cc6152 | 459 | c_type_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
460 | { |
461 | struct type *type = NULL; | |
462 | ||
463 | c_describe_child (parent, index, NULL, NULL, &type, NULL); | |
464 | return type; | |
465 | } | |
466 | ||
467 | /* This returns the type of the variable. It also skips past typedefs | |
468 | to return the real type of the variable. */ | |
469 | ||
470 | static struct type * | |
b09e2c59 | 471 | get_type (const struct varobj *var) |
99ad9427 YQ |
472 | { |
473 | struct type *type; | |
474 | ||
475 | type = var->type; | |
476 | if (type != NULL) | |
477 | type = check_typedef (type); | |
478 | ||
479 | return type; | |
480 | } | |
481 | ||
482 | static char * | |
b09e2c59 SM |
483 | c_value_of_variable (const struct varobj *var, |
484 | enum varobj_display_formats format) | |
99ad9427 YQ |
485 | { |
486 | /* BOGUS: if val_print sees a struct/class, or a reference to one, | |
487 | it will print out its children instead of "{...}". So we need to | |
488 | catch that case explicitly. */ | |
489 | struct type *type = get_type (var); | |
490 | ||
491 | /* Strip top-level references. */ | |
492 | while (TYPE_CODE (type) == TYPE_CODE_REF) | |
493 | type = check_typedef (TYPE_TARGET_TYPE (type)); | |
494 | ||
495 | switch (TYPE_CODE (type)) | |
496 | { | |
497 | case TYPE_CODE_STRUCT: | |
498 | case TYPE_CODE_UNION: | |
499 | return xstrdup ("{...}"); | |
500 | /* break; */ | |
501 | ||
502 | case TYPE_CODE_ARRAY: | |
503 | { | |
504 | char *number; | |
505 | ||
506 | number = xstrprintf ("[%d]", var->num_children); | |
507 | return (number); | |
508 | } | |
509 | /* break; */ | |
510 | ||
511 | default: | |
512 | { | |
513 | if (var->value == NULL) | |
514 | { | |
515 | /* This can happen if we attempt to get the value of a struct | |
516 | member when the parent is an invalid pointer. This is an | |
517 | error condition, so we should tell the caller. */ | |
518 | return NULL; | |
519 | } | |
520 | else | |
521 | { | |
522 | if (var->not_fetched && value_lazy (var->value)) | |
523 | /* Frozen variable and no value yet. We don't | |
524 | implicitly fetch the value. MI response will | |
525 | use empty string for the value, which is OK. */ | |
526 | return NULL; | |
527 | ||
528 | gdb_assert (varobj_value_is_changeable_p (var)); | |
529 | gdb_assert (!value_lazy (var->value)); | |
530 | ||
531 | /* If the specified format is the current one, | |
532 | we can reuse print_value. */ | |
533 | if (format == var->format) | |
534 | return xstrdup (var->print_value); | |
535 | else | |
536 | return varobj_value_get_print_value (var->value, format, var); | |
537 | } | |
538 | } | |
539 | } | |
540 | } | |
541 | \f | |
542 | ||
543 | /* varobj operations for c. */ | |
544 | ||
545 | const struct lang_varobj_ops c_varobj_ops = | |
546 | { | |
547 | c_number_of_children, | |
548 | c_name_of_variable, | |
549 | c_name_of_child, | |
550 | c_path_expr_of_child, | |
551 | c_value_of_child, | |
552 | c_type_of_child, | |
553 | c_value_of_variable, | |
554 | varobj_default_value_is_changeable_p, | |
9a9a7608 AB |
555 | NULL, /* value_has_mutated */ |
556 | c_is_path_expr_parent /* is_path_expr_parent */ | |
99ad9427 YQ |
557 | }; |
558 | ||
559 | /* A little convenience enum for dealing with C++/Java. */ | |
560 | enum vsections | |
561 | { | |
562 | v_public = 0, v_private, v_protected | |
563 | }; | |
564 | ||
565 | /* C++ */ | |
566 | ||
567 | static int | |
b09e2c59 | 568 | cplus_number_of_children (const struct varobj *var) |
99ad9427 YQ |
569 | { |
570 | struct value *value = NULL; | |
571 | struct type *type; | |
572 | int children, dont_know; | |
573 | int lookup_actual_type = 0; | |
574 | struct value_print_options opts; | |
575 | ||
576 | dont_know = 1; | |
577 | children = 0; | |
578 | ||
579 | get_user_print_options (&opts); | |
580 | ||
581 | if (!CPLUS_FAKE_CHILD (var)) | |
582 | { | |
583 | type = varobj_get_value_type (var); | |
584 | ||
585 | /* It is necessary to access a real type (via RTTI). */ | |
586 | if (opts.objectprint) | |
587 | { | |
588 | value = var->value; | |
589 | lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF | |
590 | || TYPE_CODE (var->type) == TYPE_CODE_PTR); | |
591 | } | |
592 | adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); | |
593 | ||
0c6faab5 YQ |
594 | if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) |
595 | || ((TYPE_CODE (type)) == TYPE_CODE_UNION)) | |
99ad9427 YQ |
596 | { |
597 | int kids[3]; | |
598 | ||
599 | cplus_class_num_children (type, kids); | |
600 | if (kids[v_public] != 0) | |
601 | children++; | |
602 | if (kids[v_private] != 0) | |
603 | children++; | |
604 | if (kids[v_protected] != 0) | |
605 | children++; | |
606 | ||
607 | /* Add any baseclasses. */ | |
608 | children += TYPE_N_BASECLASSES (type); | |
609 | dont_know = 0; | |
610 | ||
611 | /* FIXME: save children in var. */ | |
612 | } | |
613 | } | |
614 | else | |
615 | { | |
616 | int kids[3]; | |
617 | ||
618 | type = varobj_get_value_type (var->parent); | |
619 | ||
620 | /* It is necessary to access a real type (via RTTI). */ | |
621 | if (opts.objectprint) | |
622 | { | |
c1cc6152 | 623 | const struct varobj *parent = var->parent; |
99ad9427 YQ |
624 | |
625 | value = parent->value; | |
626 | lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF | |
627 | || TYPE_CODE (parent->type) == TYPE_CODE_PTR); | |
628 | } | |
629 | adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); | |
630 | ||
631 | cplus_class_num_children (type, kids); | |
632 | if (strcmp (var->name, "public") == 0) | |
633 | children = kids[v_public]; | |
634 | else if (strcmp (var->name, "private") == 0) | |
635 | children = kids[v_private]; | |
636 | else | |
637 | children = kids[v_protected]; | |
638 | dont_know = 0; | |
639 | } | |
640 | ||
641 | if (dont_know) | |
642 | children = c_number_of_children (var); | |
643 | ||
644 | return children; | |
645 | } | |
646 | ||
647 | /* Compute # of public, private, and protected variables in this class. | |
648 | That means we need to descend into all baseclasses and find out | |
649 | how many are there, too. */ | |
650 | ||
651 | static void | |
652 | cplus_class_num_children (struct type *type, int children[3]) | |
653 | { | |
654 | int i, vptr_fieldno; | |
655 | struct type *basetype = NULL; | |
656 | ||
657 | children[v_public] = 0; | |
658 | children[v_private] = 0; | |
659 | children[v_protected] = 0; | |
660 | ||
661 | vptr_fieldno = get_vptr_fieldno (type, &basetype); | |
662 | for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++) | |
663 | { | |
664 | /* If we have a virtual table pointer, omit it. Even if virtual | |
665 | table pointers are not specifically marked in the debug info, | |
666 | they should be artificial. */ | |
667 | if ((type == basetype && i == vptr_fieldno) | |
668 | || TYPE_FIELD_ARTIFICIAL (type, i)) | |
669 | continue; | |
670 | ||
671 | if (TYPE_FIELD_PROTECTED (type, i)) | |
672 | children[v_protected]++; | |
673 | else if (TYPE_FIELD_PRIVATE (type, i)) | |
674 | children[v_private]++; | |
675 | else | |
676 | children[v_public]++; | |
677 | } | |
678 | } | |
679 | ||
680 | static char * | |
b09e2c59 | 681 | cplus_name_of_variable (const struct varobj *parent) |
99ad9427 YQ |
682 | { |
683 | return c_name_of_variable (parent); | |
684 | } | |
685 | ||
686 | enum accessibility { private_field, protected_field, public_field }; | |
687 | ||
688 | /* Check if field INDEX of TYPE has the specified accessibility. | |
689 | Return 0 if so and 1 otherwise. */ | |
690 | ||
691 | static int | |
692 | match_accessibility (struct type *type, int index, enum accessibility acc) | |
693 | { | |
694 | if (acc == private_field && TYPE_FIELD_PRIVATE (type, index)) | |
695 | return 1; | |
696 | else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index)) | |
697 | return 1; | |
698 | else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index) | |
699 | && !TYPE_FIELD_PROTECTED (type, index)) | |
700 | return 1; | |
701 | else | |
702 | return 0; | |
703 | } | |
704 | ||
705 | static void | |
c1cc6152 | 706 | cplus_describe_child (const struct varobj *parent, int index, |
99ad9427 YQ |
707 | char **cname, struct value **cvalue, struct type **ctype, |
708 | char **cfull_expression) | |
709 | { | |
710 | struct value *value; | |
711 | struct type *type; | |
712 | int was_ptr; | |
713 | int lookup_actual_type = 0; | |
714 | char *parent_expression = NULL; | |
c1cc6152 | 715 | const struct varobj *var; |
99ad9427 YQ |
716 | struct value_print_options opts; |
717 | ||
718 | if (cname) | |
719 | *cname = NULL; | |
720 | if (cvalue) | |
721 | *cvalue = NULL; | |
722 | if (ctype) | |
723 | *ctype = NULL; | |
724 | if (cfull_expression) | |
725 | *cfull_expression = NULL; | |
726 | ||
727 | get_user_print_options (&opts); | |
728 | ||
729 | var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent; | |
730 | if (opts.objectprint) | |
731 | lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF | |
732 | || TYPE_CODE (var->type) == TYPE_CODE_PTR); | |
733 | value = var->value; | |
734 | type = varobj_get_value_type (var); | |
735 | if (cfull_expression) | |
736 | parent_expression | |
737 | = varobj_get_path_expr (varobj_get_path_expr_parent (var)); | |
738 | ||
739 | adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type); | |
740 | ||
741 | if (TYPE_CODE (type) == TYPE_CODE_STRUCT | |
742 | || TYPE_CODE (type) == TYPE_CODE_UNION) | |
743 | { | |
744 | char *join = was_ptr ? "->" : "."; | |
745 | ||
746 | if (CPLUS_FAKE_CHILD (parent)) | |
747 | { | |
748 | /* The fields of the class type are ordered as they | |
749 | appear in the class. We are given an index for a | |
750 | particular access control type ("public","protected", | |
751 | or "private"). We must skip over fields that don't | |
752 | have the access control we are looking for to properly | |
753 | find the indexed field. */ | |
754 | int type_index = TYPE_N_BASECLASSES (type); | |
755 | enum accessibility acc = public_field; | |
756 | int vptr_fieldno; | |
757 | struct type *basetype = NULL; | |
758 | const char *field_name; | |
759 | ||
760 | vptr_fieldno = get_vptr_fieldno (type, &basetype); | |
761 | if (strcmp (parent->name, "private") == 0) | |
762 | acc = private_field; | |
763 | else if (strcmp (parent->name, "protected") == 0) | |
764 | acc = protected_field; | |
765 | ||
766 | while (index >= 0) | |
767 | { | |
768 | if ((type == basetype && type_index == vptr_fieldno) | |
769 | || TYPE_FIELD_ARTIFICIAL (type, type_index)) | |
770 | ; /* ignore vptr */ | |
771 | else if (match_accessibility (type, type_index, acc)) | |
772 | --index; | |
773 | ++type_index; | |
774 | } | |
775 | --type_index; | |
776 | ||
777 | /* If the type is anonymous and the field has no name, | |
778 | set an appopriate name. */ | |
779 | field_name = TYPE_FIELD_NAME (type, type_index); | |
780 | if (field_name == NULL || *field_name == '\0') | |
781 | { | |
782 | if (cname) | |
783 | { | |
784 | if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index)) | |
785 | == TYPE_CODE_STRUCT) | |
786 | *cname = xstrdup (ANONYMOUS_STRUCT_NAME); | |
787 | else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index)) | |
788 | == TYPE_CODE_UNION) | |
789 | *cname = xstrdup (ANONYMOUS_UNION_NAME); | |
790 | } | |
791 | ||
792 | if (cfull_expression) | |
793 | *cfull_expression = xstrdup (""); | |
794 | } | |
795 | else | |
796 | { | |
797 | if (cname) | |
798 | *cname = xstrdup (TYPE_FIELD_NAME (type, type_index)); | |
799 | ||
800 | if (cfull_expression) | |
801 | *cfull_expression | |
802 | = xstrprintf ("((%s)%s%s)", parent_expression, join, | |
803 | field_name); | |
804 | } | |
805 | ||
806 | if (cvalue && value) | |
807 | *cvalue = value_struct_element_index (value, type_index); | |
808 | ||
809 | if (ctype) | |
810 | *ctype = TYPE_FIELD_TYPE (type, type_index); | |
811 | } | |
812 | else if (index < TYPE_N_BASECLASSES (type)) | |
813 | { | |
814 | /* This is a baseclass. */ | |
815 | if (cname) | |
816 | *cname = xstrdup (TYPE_FIELD_NAME (type, index)); | |
817 | ||
818 | if (cvalue && value) | |
819 | *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value); | |
820 | ||
821 | if (ctype) | |
822 | { | |
823 | *ctype = TYPE_FIELD_TYPE (type, index); | |
824 | } | |
825 | ||
826 | if (cfull_expression) | |
827 | { | |
828 | char *ptr = was_ptr ? "*" : ""; | |
829 | ||
830 | /* Cast the parent to the base' type. Note that in gdb, | |
831 | expression like | |
832 | (Base1)d | |
833 | will create an lvalue, for all appearences, so we don't | |
834 | need to use more fancy: | |
835 | *(Base1*)(&d) | |
836 | construct. | |
837 | ||
838 | When we are in the scope of the base class or of one | |
839 | of its children, the type field name will be interpreted | |
840 | as a constructor, if it exists. Therefore, we must | |
841 | indicate that the name is a class name by using the | |
842 | 'class' keyword. See PR mi/11912 */ | |
843 | *cfull_expression = xstrprintf ("(%s(class %s%s) %s)", | |
844 | ptr, | |
845 | TYPE_FIELD_NAME (type, index), | |
846 | ptr, | |
847 | parent_expression); | |
848 | } | |
849 | } | |
850 | else | |
851 | { | |
852 | char *access = NULL; | |
853 | int children[3]; | |
854 | ||
855 | cplus_class_num_children (type, children); | |
856 | ||
857 | /* Everything beyond the baseclasses can | |
858 | only be "public", "private", or "protected" | |
859 | ||
860 | The special "fake" children are always output by varobj in | |
861 | this order. So if INDEX == 2, it MUST be "protected". */ | |
862 | index -= TYPE_N_BASECLASSES (type); | |
863 | switch (index) | |
864 | { | |
865 | case 0: | |
866 | if (children[v_public] > 0) | |
867 | access = "public"; | |
868 | else if (children[v_private] > 0) | |
869 | access = "private"; | |
870 | else | |
871 | access = "protected"; | |
872 | break; | |
873 | case 1: | |
874 | if (children[v_public] > 0) | |
875 | { | |
876 | if (children[v_private] > 0) | |
877 | access = "private"; | |
878 | else | |
879 | access = "protected"; | |
880 | } | |
881 | else if (children[v_private] > 0) | |
882 | access = "protected"; | |
883 | break; | |
884 | case 2: | |
885 | /* Must be protected. */ | |
886 | access = "protected"; | |
887 | break; | |
888 | default: | |
889 | /* error! */ | |
890 | break; | |
891 | } | |
892 | ||
893 | gdb_assert (access); | |
894 | if (cname) | |
895 | *cname = xstrdup (access); | |
896 | ||
897 | /* Value and type and full expression are null here. */ | |
898 | } | |
899 | } | |
900 | else | |
901 | { | |
902 | c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression); | |
903 | } | |
904 | } | |
905 | ||
906 | static char * | |
c1cc6152 | 907 | cplus_name_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
908 | { |
909 | char *name = NULL; | |
910 | ||
911 | cplus_describe_child (parent, index, &name, NULL, NULL, NULL); | |
912 | return name; | |
913 | } | |
914 | ||
915 | static char * | |
b09e2c59 | 916 | cplus_path_expr_of_child (const struct varobj *child) |
99ad9427 | 917 | { |
2568868e SM |
918 | char *path_expr; |
919 | ||
99ad9427 | 920 | cplus_describe_child (child->parent, child->index, NULL, NULL, NULL, |
2568868e SM |
921 | &path_expr); |
922 | return path_expr; | |
99ad9427 YQ |
923 | } |
924 | ||
925 | static struct value * | |
c1cc6152 | 926 | cplus_value_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
927 | { |
928 | struct value *value = NULL; | |
929 | ||
930 | cplus_describe_child (parent, index, NULL, &value, NULL, NULL); | |
931 | return value; | |
932 | } | |
933 | ||
934 | static struct type * | |
c1cc6152 | 935 | cplus_type_of_child (const struct varobj *parent, int index) |
99ad9427 YQ |
936 | { |
937 | struct type *type = NULL; | |
938 | ||
939 | cplus_describe_child (parent, index, NULL, NULL, &type, NULL); | |
940 | return type; | |
941 | } | |
942 | ||
943 | static char * | |
b09e2c59 | 944 | cplus_value_of_variable (const struct varobj *var, |
99ad9427 YQ |
945 | enum varobj_display_formats format) |
946 | { | |
947 | ||
948 | /* If we have one of our special types, don't print out | |
949 | any value. */ | |
950 | if (CPLUS_FAKE_CHILD (var)) | |
951 | return xstrdup (""); | |
952 | ||
953 | return c_value_of_variable (var, format); | |
954 | } | |
955 | \f | |
956 | ||
957 | /* varobj operations for c++. */ | |
958 | ||
959 | const struct lang_varobj_ops cplus_varobj_ops = | |
960 | { | |
961 | cplus_number_of_children, | |
962 | cplus_name_of_variable, | |
963 | cplus_name_of_child, | |
964 | cplus_path_expr_of_child, | |
965 | cplus_value_of_child, | |
966 | cplus_type_of_child, | |
967 | cplus_value_of_variable, | |
968 | varobj_default_value_is_changeable_p, | |
9a9a7608 AB |
969 | NULL, /* value_has_mutated */ |
970 | c_is_path_expr_parent /* is_path_expr_parent */ | |
99ad9427 YQ |
971 | }; |
972 | ||
973 | \f |