From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26800 invoked by alias); 18 Sep 2013 13:55:43 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 26696 invoked by uid 89); 18 Sep 2013 13:55:42 -0000 Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 18 Sep 2013 13:55:42 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.2 required=5.0 tests=AWL,BAYES_50,KHOP_THREADED,RDNS_NONE,SPF_HELO_FAIL autolearn=no version=3.3.2 X-HELO: relay1.mentorg.com Received: from svr-orw-fem-01.mgc.mentorg.com ([147.34.98.93]) by relay1.mentorg.com with esmtp id 1VMIEC-0006XM-DM from Yao_Qi@mentor.com for gdb-patches@sourceware.org; Wed, 18 Sep 2013 06:55:36 -0700 Received: from SVR-ORW-FEM-04.mgc.mentorg.com ([147.34.97.41]) by svr-orw-fem-01.mgc.mentorg.com over TLS secured channel with Microsoft SMTPSVC(6.0.3790.4675); Wed, 18 Sep 2013 06:55:36 -0700 Received: from qiyao.dyndns.org (147.34.91.1) by svr-orw-fem-04.mgc.mentorg.com (147.34.97.41) with Microsoft SMTP Server id 14.2.247.3; Wed, 18 Sep 2013 06:55:34 -0700 From: Yao Qi To: Subject: [PATCH 4/7] Move struct varobj to varobj.h. Date: Wed, 18 Sep 2013 13:55:00 -0000 Message-ID: <1379512482-31773-5-git-send-email-yao@codesourcery.com> In-Reply-To: <1379512482-31773-1-git-send-email-yao@codesourcery.com> References: <1379512482-31773-1-git-send-email-yao@codesourcery.com> MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2013-09/txt/msg00595.txt.bz2 Hi, This patch moves most of the fields of struct varobj to varobj.h, and continue to name it 'struct varobj.h' there. New struct varobj_dynamic 'extends' struct varobj in varobj.c. Move part of struct varobj to varobj.h gdb: 2013-09-18 Yao Qi * varobj.c (struct varobj): Move most of the fields to varobj.h. (struct varobj_dynamic): New struct. (varobj_get_display_hint) [HAVE_PYTHON]: Cast 'var' to type 'struct varobj_dynamic'. (varobj_has_more): Likewise. (dynamic_varobj_has_child_method): Change type of parameter 'var' to 'struct varobj_dynamic *'. (update_dynamic_varobj_children): Likewise. (install_visualizer): Likewise. (install_default_visualizer, construct_visualizer): Likewise. (varobj_get_num_children): Likewise. (dynamic_varobj_has_child_method): Adjust. (varobj_list_children, varobj_get_attributes): Likewise. (varobj_set_value, install_new_value): Likewise. (varobj_update, new_variable): Likewise. (my_value_of_variable, value_get_print_value): Likewise. * varobj.h (struct varobj): Moved from varobj.c. --- gdb/varobj.c | 239 +++++++++++++++++++++++----------------------------------- gdb/varobj.h | 74 ++++++++++++++++++ 2 files changed, 167 insertions(+), 146 deletions(-) diff --git a/gdb/varobj.c b/gdb/varobj.c index 3ecf702..672d246 100644 --- a/gdb/varobj.c +++ b/gdb/varobj.c @@ -116,48 +116,11 @@ struct varobj_root struct varobj_root *next; }; -/* Every variable in the system has a structure of this type defined - for it. This structure holds all information necessary to manipulate - a particular object variable. Members which must be freed are noted. */ -struct varobj -{ - - /* Alloc'd name of the variable for this object. If this variable is a - child, then this name will be the child's source name. - (bar, not foo.bar). */ - /* NOTE: This is the "expression". */ - char *name; - - /* Alloc'd expression for this child. Can be used to create a - root variable corresponding to this child. */ - char *path_expr; - - /* The alloc'd name for this variable's object. This is here for - convenience when constructing this object's children. */ - char *obj_name; - - /* Index of this variable in its parent or -1. */ - int index; - - /* The type of this variable. This can be NULL - for artifial variable objects -- currently, the "accessibility" - variable objects in C++. */ - struct type *type; +/* Dynamic varobj. */ - /* The value of this expression or subexpression. A NULL value - indicates there was an error getting this value. - Invariant: if varobj_value_is_changeable_p (this) is non-zero, - the value is either NULL, or not lazy. */ - struct value *value; - - /* The number of (immediate) children this variable has. */ - int num_children; - - /* If this object is a child, this points to its immediate parent. */ - struct varobj *parent; - - /* Children of this object. */ - VEC (varobj_p) *children; +struct varobj_dynamic +{ + struct varobj base; /* Whether the children of this varobj were requested. This field is used to decide if dynamic varobj should recompute their children. @@ -165,35 +128,6 @@ struct varobj can avoid that. */ int children_requested; - /* Description of the root variable. Points to root variable for - children. */ - struct varobj_root *root; - - /* The format of the output for this object. */ - enum varobj_display_formats format; - - /* Was this variable updated via a varobj_set_value operation. */ - int updated; - - /* Last print value. */ - char *print_value; - - /* Is this variable frozen. Frozen variables are never implicitly - updated by -var-update * - or -var-update . */ - int frozen; - - /* Is the value of this variable intentionally not fetched? It is - not fetched if either the variable is frozen, or any parents is - frozen. */ - int not_fetched; - - /* Sub-range of children which the MI consumer has requested. If - FROM < 0 or TO < 0, means that all children have been - requested. */ - int from; - int to; - /* The pretty-printer constructor. If NULL, then the default pretty-printer will be looked up. If None, then no pretty-printer will be installed. */ @@ -899,14 +833,15 @@ varobj_get_display_hint (struct varobj *var) #if HAVE_PYTHON struct cleanup *back_to; + PyObject *pretty_printer = ((struct varobj_dynamic *) var)->pretty_printer; if (!gdb_python_initialized) return NULL; back_to = varobj_ensure_python_env (var); - if (var->pretty_printer) - result = gdbpy_get_display_hint (var->pretty_printer); + if (pretty_printer != NULL) + result = gdbpy_get_display_hint (pretty_printer); do_cleanups (back_to); #endif @@ -922,7 +857,7 @@ varobj_has_more (struct varobj *var, int to) if (VEC_length (varobj_p, var->children) > to) return 1; return ((to == -1 || VEC_length (varobj_p, var->children) == to) - && var->saved_item != NULL); + && ((struct varobj_dynamic *) var)->saved_item != NULL); } /* If the variable object is bound to a specific thread, that @@ -1029,7 +964,7 @@ install_dynamic_child (struct varobj *var, } static int -dynamic_varobj_has_child_method (struct varobj *var) +dynamic_varobj_has_child_method (struct varobj_dynamic *var) { struct cleanup *back_to; PyObject *printer = var->pretty_printer; @@ -1038,7 +973,7 @@ dynamic_varobj_has_child_method (struct varobj *var) if (!gdb_python_initialized) return 0; - back_to = varobj_ensure_python_env (var); + back_to = varobj_ensure_python_env ((struct varobj *) var); result = PyObject_HasAttr (printer, gdbpy_children_cst); do_cleanups (back_to); return result; @@ -1047,7 +982,7 @@ dynamic_varobj_has_child_method (struct varobj *var) #endif static int -update_dynamic_varobj_children (struct varobj *var, +update_dynamic_varobj_children (struct varobj_dynamic *var, VEC (varobj_p) **changed, VEC (varobj_p) **type_changed, VEC (varobj_p) **new, @@ -1066,7 +1001,7 @@ update_dynamic_varobj_children (struct varobj *var, if (!gdb_python_initialized) return 0; - back_to = varobj_ensure_python_env (var); + back_to = varobj_ensure_python_env ((struct varobj *) var); *cchanged = 0; if (!PyObject_HasAttr (printer, gdbpy_children_cst)) @@ -1102,7 +1037,7 @@ update_dynamic_varobj_children (struct varobj *var, i = 0; } else - i = VEC_length (varobj_p, var->children); + i = VEC_length (varobj_p, var->base.children); /* We ask for one extra child, so that MI can report whether there are more children. */ @@ -1184,7 +1119,8 @@ update_dynamic_varobj_children (struct varobj *var, v = convert_value_from_python (py_v); if (v == NULL) gdbpy_print_stack (); - install_dynamic_child (var, can_mention ? changed : NULL, + install_dynamic_child ((struct varobj *) var, + can_mention ? changed : NULL, can_mention ? type_changed : NULL, can_mention ? new : NULL, can_mention ? unchanged : NULL, @@ -1205,22 +1141,22 @@ update_dynamic_varobj_children (struct varobj *var, break; } - if (i < VEC_length (varobj_p, var->children)) + if (i < VEC_length (varobj_p, var->base.children)) { int j; *cchanged = 1; - for (j = i; j < VEC_length (varobj_p, var->children); ++j) - varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0); - VEC_truncate (varobj_p, var->children, i); + for (j = i; j < VEC_length (varobj_p, var->base.children); ++j) + varobj_delete (VEC_index (varobj_p, var->base.children, j), NULL, 0); + VEC_truncate (varobj_p, var->base.children, i); } /* If there are fewer children than requested, note that the list of children changed. */ - if (to >= 0 && VEC_length (varobj_p, var->children) < to) + if (to >= 0 && VEC_length (varobj_p, var->base.children) < to) *cchanged = 1; - var->num_children = VEC_length (varobj_p, var->children); + var->base.num_children = VEC_length (varobj_p, var->base.children); do_cleanups (back_to); @@ -1235,14 +1171,16 @@ varobj_get_num_children (struct varobj *var) { if (var->num_children == -1) { - if (var->pretty_printer) + struct varobj_dynamic *var_dyn = (struct varobj_dynamic *) var; + + if (var_dyn->pretty_printer) { int dummy; /* If we have a dynamic varobj, don't report -1 children. So, try to fetch some children first. */ - update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy, - 0, 0, 0); + update_dynamic_varobj_children (var_dyn, NULL, NULL, NULL, + NULL, &dummy, 0, 0, 0); } else var->num_children = number_of_children (var); @@ -1259,15 +1197,16 @@ varobj_list_children (struct varobj *var, int *from, int *to) { char *name; int i, children_changed; + struct varobj_dynamic *var_dyn = (struct varobj_dynamic *) var; - var->children_requested = 1; + var_dyn->children_requested = 1; - if (var->pretty_printer) + if (var_dyn->pretty_printer) { /* This, in theory, can result in the number of children changing without frontend noticing. But well, calling -var-list-children on the same varobj twice is not something a sane frontend would do. */ - update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, + update_dynamic_varobj_children (var_dyn, NULL, NULL, NULL, NULL, &children_changed, 0, 0, *to); restrict_range (var->children, from, to); return var->children; @@ -1413,7 +1352,7 @@ varobj_get_attributes (struct varobj *var) int varobj_pretty_printed_p (struct varobj *var) { - return var->pretty_printer != NULL; + return ((struct varobj_dynamic *) var)->pretty_printer != NULL; } char * @@ -1504,7 +1443,7 @@ varobj_set_value (struct varobj *var, char *expression) in a varobj. */ static void -install_visualizer (struct varobj *var, PyObject *constructor, +install_visualizer (struct varobj_dynamic *var, PyObject *constructor, PyObject *visualizer) { Py_XDECREF (var->constructor); @@ -1520,19 +1459,19 @@ install_visualizer (struct varobj *var, PyObject *constructor, /* Install the default visualizer for VAR. */ static void -install_default_visualizer (struct varobj *var) +install_default_visualizer (struct varobj_dynamic *var) { /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */ - if (CPLUS_FAKE_CHILD (var)) + if (CPLUS_FAKE_CHILD (&var->base)) return; if (pretty_printing) { PyObject *pretty_printer = NULL; - if (var->value) + if (var->base.value != NULL) { - pretty_printer = gdbpy_get_varobj_pretty_printer (var->value); + pretty_printer = gdbpy_get_varobj_pretty_printer (var->base.value); if (! pretty_printer) { gdbpy_print_stack (); @@ -1554,12 +1493,12 @@ install_default_visualizer (struct varobj *var) make a new object. */ static void -construct_visualizer (struct varobj *var, PyObject *constructor) +construct_visualizer (struct varobj_dynamic *var, PyObject *constructor) { PyObject *pretty_printer; /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */ - if (CPLUS_FAKE_CHILD (var)) + if (CPLUS_FAKE_CHILD (&var->base)) return; Py_INCREF (constructor); @@ -1567,7 +1506,8 @@ construct_visualizer (struct varobj *var, PyObject *constructor) pretty_printer = NULL; else { - pretty_printer = instantiate_pretty_printer (constructor, var->value); + pretty_printer = instantiate_pretty_printer (constructor, + var->base.value); if (! pretty_printer) { gdbpy_print_stack (); @@ -1592,7 +1532,7 @@ construct_visualizer (struct varobj *var, PyObject *constructor) a visualizer for VAR, if appropriate. */ static void -install_new_value_visualizer (struct varobj *var) +install_new_value_visualizer (struct varobj_dynamic *var) { #if HAVE_PYTHON /* If the constructor is None, then we want the raw value. If VAR @@ -1600,13 +1540,13 @@ install_new_value_visualizer (struct varobj *var) if (!gdb_python_initialized) return; - if (var->constructor != Py_None && var->value) + if (var->constructor != Py_None && var->base.value) { struct cleanup *cleanup; - cleanup = varobj_ensure_python_env (var); + cleanup = varobj_ensure_python_env ((struct varobj *) var); - if (!var->constructor) + if (var->constructor == NULL) install_default_visualizer (var); else construct_visualizer (var, var->constructor); @@ -1676,6 +1616,7 @@ install_new_value (struct varobj *var, struct value *value, int initial) int changed = 0; int intentionally_not_fetched = 0; char *print_value = NULL; + struct varobj_dynamic *var_dyn = (struct varobj_dynamic *) var; /* We need to know the varobj's type to decide if the value should be fetched or not. C++ fake children (public/protected/private) @@ -1686,7 +1627,7 @@ install_new_value (struct varobj *var, struct value *value, int initial) /* If the type has custom visualizer, we consider it to be always changeable. FIXME: need to make sure this behaviour will not mess up read-sensitive values. */ - if (var->pretty_printer) + if (var_dyn->pretty_printer != NULL) changeable = 1; need_to_fetch = changeable; @@ -1757,7 +1698,7 @@ install_new_value (struct varobj *var, struct value *value, int initial) values. Don't get string rendering if the value is lazy -- if it is, the code above has decided that the value should not be fetched. */ - if (value && !value_lazy (value) && !var->pretty_printer) + if (value && !value_lazy (value) && var_dyn->pretty_printer == NULL) print_value = value_get_print_value (value, var->format, var); /* If the type is changeable, compare the old and the new values. @@ -1774,7 +1715,7 @@ install_new_value (struct varobj *var, struct value *value, int initial) { changed = 1; } - else if (! var->pretty_printer) + else if (var_dyn->pretty_printer == NULL) { /* Try to compare the values. That requires that both values are non-lazy. */ @@ -1825,11 +1766,11 @@ install_new_value (struct varobj *var, struct value *value, int initial) var->not_fetched = 0; var->updated = 0; - install_new_value_visualizer (var); + install_new_value_visualizer (var_dyn); /* If we installed a pretty-printer, re-compare the printed version to see if the variable changed. */ - if (var->pretty_printer) + if (var_dyn->pretty_printer != NULL) { xfree (print_value); print_value = value_get_print_value (var->value, var->format, var); @@ -1894,7 +1835,7 @@ varobj_set_visualizer (struct varobj *var, const char *visualizer) error (_("Could not evaluate visualizer expression: %s"), visualizer); } - construct_visualizer (var, constructor); + construct_visualizer ((struct varobj_dynamic *) var, constructor); Py_XDECREF (constructor); /* If there are any children now, wipe them. */ @@ -2019,6 +1960,7 @@ varobj_update (struct varobj **varp, int explicit) { varobj_update_result r = *(VEC_last (varobj_update_result, stack)); struct varobj *v = r.varobj; + struct varobj_dynamic *v_dyn = (struct varobj_dynamic *) v; VEC_pop (varobj_update_result, stack); @@ -2058,7 +2000,7 @@ varobj_update (struct varobj **varp, int explicit) /* We probably should not get children of a varobj that has a pretty-printer, but for which -var-list-children was never invoked. */ - if (v->pretty_printer) + if (v_dyn->pretty_printer != NULL) { VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0; VEC (varobj_p) *new = 0; @@ -2067,7 +2009,7 @@ varobj_update (struct varobj **varp, int explicit) if (v->frozen) continue; - if (!v->children_requested) + if (!v_dyn->children_requested) { int dummy; @@ -2079,8 +2021,8 @@ varobj_update (struct varobj **varp, int explicit) it. */ if (!varobj_has_more (v, 0)) { - update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL, - &dummy, 0, 0, 0); + update_dynamic_varobj_children (v_dyn, NULL, NULL, NULL, + NULL, &dummy, 0, 0, 0); if (varobj_has_more (v, 0)) r.changed = 1; } @@ -2093,9 +2035,10 @@ varobj_update (struct varobj **varp, int explicit) /* If update_dynamic_varobj_children returns 0, then we have a non-conforming pretty-printer, so we skip it. */ - if (update_dynamic_varobj_children (v, &changed, &type_changed, &new, - &unchanged, &children_changed, 1, - v->from, v->to)) + if (update_dynamic_varobj_children (v_dyn, &changed, &type_changed, + &new, &unchanged, + &children_changed, 1, v->from, + v->to)) { if (children_changed || new) { @@ -2441,33 +2384,33 @@ create_child_with_value (struct varobj *parent, int index, const char *name, static struct varobj * new_variable (void) { - struct varobj *var; - - var = (struct varobj *) xmalloc (sizeof (struct varobj)); - var->name = NULL; - var->path_expr = NULL; - var->obj_name = NULL; - var->index = -1; - var->type = NULL; - var->value = NULL; - var->num_children = -1; - var->parent = NULL; - var->children = NULL; - var->format = 0; - var->root = NULL; - var->updated = 0; - var->print_value = NULL; - var->frozen = 0; - var->not_fetched = 0; + struct varobj_dynamic *var; + + var = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic)); + var->base.name = NULL; + var->base.path_expr = NULL; + var->base.obj_name = NULL; + var->base.index = -1; + var->base.type = NULL; + var->base.value = NULL; + var->base.num_children = -1; + var->base.parent = NULL; + var->base.children = NULL; + var->base.format = 0; + var->base.root = NULL; + var->base.updated = 0; + var->base.print_value = NULL; + var->base.frozen = 0; + var->base.not_fetched = 0; var->children_requested = 0; - var->from = -1; - var->to = -1; + var->base.from = -1; + var->base.to = -1; var->constructor = 0; var->pretty_printer = 0; var->child_iter = 0; var->saved_item = 0; - return var; + return (struct varobj *) var; } /* Allocate memory and initialize a new root variable. */ @@ -2493,13 +2436,16 @@ static void free_variable (struct varobj *var) { #if HAVE_PYTHON - if (var->pretty_printer) + struct varobj_dynamic *var_dyn = (struct varobj_dynamic *) var; + + if (var_dyn->pretty_printer) { struct cleanup *cleanup = varobj_ensure_python_env (var); - Py_XDECREF (var->constructor); - Py_XDECREF (var->pretty_printer); - Py_XDECREF (var->child_iter); - Py_XDECREF (var->saved_item); + + Py_XDECREF (var_dyn->constructor); + Py_XDECREF (var_dyn->pretty_printer); + Py_XDECREF (var_dyn->child_iter); + Py_XDECREF (var_dyn->saved_item); do_cleanups (cleanup); } #endif @@ -2889,7 +2835,7 @@ my_value_of_variable (struct varobj *var, enum varobj_display_formats format) { if (var->root->is_valid) { - if (var->pretty_printer) + if (((struct varobj_dynamic *) var)->pretty_printer) return value_get_print_value (var->value, var->format, var); return (*var->root->lang->value_of_variable) (var, format); } @@ -2923,7 +2869,8 @@ value_get_print_value (struct value *value, enum varobj_display_formats format, #if HAVE_PYTHON if (gdb_python_initialized) { - PyObject *value_formatter = var->pretty_printer; + PyObject *value_formatter + = ((struct varobj_dynamic *) var)->pretty_printer; varobj_ensure_python_env (var); @@ -2931,7 +2878,7 @@ value_get_print_value (struct value *value, enum varobj_display_formats format, { /* First check to see if we have any children at all. If so, we simply return {...}. */ - if (dynamic_varobj_has_child_method (var)) + if (dynamic_varobj_has_child_method ((struct varobj_dynamic *) var)) { do_cleanups (old_chain); return xstrdup ("{...}"); diff --git a/gdb/varobj.h b/gdb/varobj.h index d4abb99..894ba03 100644 --- a/gdb/varobj.h +++ b/gdb/varobj.h @@ -88,6 +88,80 @@ typedef struct varobj_update_result_t DEF_VEC_O (varobj_update_result); +struct varobj_root; + +/* Every variable in the system has a structure of this type defined + for it. This structure holds all information necessary to manipulate + a particular object variable. Members which must be freed are noted. */ +struct varobj +{ + /* Alloc'd name of the variable for this object. If this variable is a + child, then this name will be the child's source name. + (bar, not foo.bar). */ + /* NOTE: This is the "expression". */ + char *name; + + /* Alloc'd expression for this child. Can be used to create a + root variable corresponding to this child. */ + char *path_expr; + + /* The alloc'd name for this variable's object. This is here for + convenience when constructing this object's children. */ + char *obj_name; + + /* Index of this variable in its parent or -1. */ + int index; + + /* The type of this variable. This can be NULL + for artifial variable objects -- currently, the "accessibility" + variable objects in C++. */ + struct type *type; + + /* The value of this expression or subexpression. A NULL value + indicates there was an error getting this value. + Invariant: if varobj_value_is_changeable_p (this) is non-zero, + the value is either NULL, or not lazy. */ + struct value *value; + + /* The number of (immediate) children this variable has. */ + int num_children; + + /* If this object is a child, this points to its immediate parent. */ + struct varobj *parent; + + /* Children of this object. */ + VEC (varobj_p) *children; + + /* Description of the root variable. Points to root variable for + children. */ + struct varobj_root *root; + + /* The format of the output for this object. */ + enum varobj_display_formats format; + + /* Was this variable updated via a varobj_set_value operation. */ + int updated; + + /* Last print value. */ + char *print_value; + + /* Is this variable frozen. Frozen variables are never implicitly + updated by -var-update * + or -var-update . */ + int frozen; + + /* Is the value of this variable intentionally not fetched? It is + not fetched if either the variable is frozen, or any parents is + frozen. */ + int not_fetched; + + /* Sub-range of children which the MI consumer has requested. If + FROM < 0 or TO < 0, means that all children have been + requested. */ + int from; + int to; +}; + /* API functions */ extern struct varobj *varobj_create (char *objname, -- 1.7.7.6