From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 22694 invoked by alias); 24 Nov 2013 02:12:13 -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 22452 invoked by uid 89); 24 Nov 2013 02:12:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.1 required=5.0 tests=AWL,BAYES_50,RDNS_NONE,URIBL_BLOCKED autolearn=no version=3.3.2 X-HELO: relay1.mentorg.com Received: from Unknown (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 24 Nov 2013 02:12:05 +0000 Received: from svr-orw-exc-10.mgc.mentorg.com ([147.34.98.58]) by relay1.mentorg.com with esmtp id 1VkPAz-0006qZ-Ne from Yao_Qi@mentor.com for gdb-patches@sourceware.org; Sat, 23 Nov 2013 18:11:57 -0800 Received: from SVR-ORW-FEM-02.mgc.mentorg.com ([147.34.96.206]) by SVR-ORW-EXC-10.mgc.mentorg.com with Microsoft SMTPSVC(6.0.3790.4675); Sat, 23 Nov 2013 18:11:57 -0800 Received: from qiyao.dyndns.org (147.34.91.1) by svr-orw-fem-02.mgc.mentorg.com (147.34.96.168) with Microsoft SMTP Server id 14.2.247.3; Sat, 23 Nov 2013 18:11:55 -0800 From: Yao Qi To: Subject: [PATCH 07/11] MI option --available-children-only Date: Sun, 24 Nov 2013 02:12:00 -0000 Message-ID: <1385258996-26047-8-git-send-email-yao@codesourcery.com> In-Reply-To: <1385258996-26047-1-git-send-email-yao@codesourcery.com> References: <1385258996-26047-1-git-send-email-yao@codesourcery.com> MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2013-11/txt/msg00733.txt.bz2 This patch adds option --available-children-only to three MI commands, parse it, and set corresponding field of 'struct varobj_dynamic'. gdb: 2013-11-24 Pedro Alves Yao Qi * mi/mi-cmd-var.c (mi_cmd_var_create): Use mi_getopt to parse options. Handle "--available-children-only". (mi_cmd_var_info_num_children): Likewise. (mi_cmd_var_list_children): Likewise. * varobj.c (struct varobj_dynamic) : New. (new_variable, new_root_variable): Update declaration. (varobj_is_dynamic_p): Return true if available-children-only is true. (varobj_create): Add new argument "available_children_only". Callers update. (varobj_get_num_children): Handle "available_children_only" (varobj_set_available_children_only): New function. (varobj_list_children): Handle "available_children_only". (install_new_value): Likewise. (varobj_update): Likewise. (new_variable): Add new argument "available_children_only". (new_root_variable): Likewise. (varobj_invalidate_iter): Likewise. * varobj.h (varobj_create): Update declaration. (varobj_set_available_children_only): Declare. --- gdb/mi/mi-cmd-var.c | 128 ++++++++++++++++++++++++++++++++++++++++++++------- gdb/varobj.c | 51 +++++++++++++++----- gdb/varobj.h | 11 ++++- 3 files changed, 160 insertions(+), 30 deletions(-) diff --git a/gdb/mi/mi-cmd-var.c b/gdb/mi/mi-cmd-var.c index 2201630..552a527 100644 --- a/gdb/mi/mi-cmd-var.c +++ b/gdb/mi/mi-cmd-var.c @@ -105,19 +105,50 @@ mi_cmd_var_create (char *command, char **argv, int argc) char *expr; struct cleanup *old_cleanups; enum varobj_type var_type; + int available_children_only = 0; + int oind = 0; + enum opt + { + AVAILABLE_CHILDREN_ONLY, + }; + static const struct mi_opt opts[] = + { + {"-available-children-only", AVAILABLE_CHILDREN_ONLY, 0}, + { 0, 0, 0 } + }; - if (argc != 3) - error (_("-var-create: Usage: NAME FRAME EXPRESSION.")); + /* Parse arguments. In this instance we are just looking for + --available_children_only. */ + while (1) + { + char *oarg; + int opt = mi_getopt ("-var-create", argc, argv, + opts, &oind, &oarg); + if (opt < 0) + break; + switch ((enum opt) opt) + { + case AVAILABLE_CHILDREN_ONLY: + available_children_only = 1; + break; + } + } - name = xstrdup (argv[0]); + + if (argc - oind != 3) + error (_("Usage: -var-create [--available-children-only] " + "NAME FRAME EXPRESSION")); + + + name = xstrdup (argv[oind]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated. */ old_cleanups = make_cleanup (free_current_contents, &name); - frame = xstrdup (argv[1]); + frame = xstrdup (argv[oind + 1]); make_cleanup (xfree, frame); - expr = xstrdup (argv[2]); + expr = xstrdup (argv[oind + 2]); make_cleanup (xfree, expr); if (strcmp (name, "-") == 0) @@ -143,7 +174,8 @@ mi_cmd_var_create (char *command, char **argv, int argc) "Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n", name, frame, hex_string (frameaddr), expr); - var = varobj_create (name, expr, frameaddr, var_type); + var = varobj_create (name, expr, frameaddr, var_type, + available_children_only); if (var == NULL) error (_("-var-create: unable to create variable object")); @@ -328,12 +360,43 @@ mi_cmd_var_info_num_children (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; + int available_children_only = 0; + int oind = 0; + enum opt + { + AVAILABLE_CHILDREN_ONLY, + }; + static const struct mi_opt opts[] = + { + {"-available-children-only", AVAILABLE_CHILDREN_ONLY, 0}, + { 0, 0, 0 } + }; - if (argc != 1) - error (_("-var-info-num-children: Usage: NAME.")); + /* Parse arguments. In this instance we are just looking for + --available_children_only. */ + while (1) + { + char *oarg; + int opt = mi_getopt ("-var-info-num-children", argc, argv, + opts, &oind, &oarg); + if (opt < 0) + break; + switch ((enum opt) opt) + { + case AVAILABLE_CHILDREN_ONLY: + available_children_only = 1; + break; + } + } + + if (argc - oind != 1) + error (_("-var-info-num-children: Usage: " + "[--available-children-only] NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ - var = varobj_get_handle (argv[0]); + var = varobj_get_handle (argv[oind]); + + varobj_set_available_children_only (var, available_children_only); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); } @@ -381,18 +444,47 @@ mi_cmd_var_list_children (char *command, char **argv, int argc) int ix; int from, to; char *display_hint; + int available_children_only = 0; + int oind = 0; + enum opt + { + AVAILABLE_CHILDREN_ONLY, + }; + static const struct mi_opt opts[] = + { + {"-available-children-only", AVAILABLE_CHILDREN_ONLY, 0}, + { 0, 0, 0 } + }; + + /* Parse arguments. In this instance we are just looking for + --available_children_only. */ + while (1) + { + char *oarg; + int opt = mi_getopt_allow_unknown ("-var-list-children", argc, argv, + opts, &oind, &oarg); + + if (opt < 0) + break; + switch ((enum opt) opt) + { + case AVAILABLE_CHILDREN_ONLY: + available_children_only = 1; + break; + } + } - if (argc < 1 || argc > 4) - error (_("-var-list-children: Usage: " + if (argc - oind < 1 || argc - oind > 4) + error (_("-var-list-children: Usage: [--available-children-only] " "[PRINT_VALUES] NAME [FROM TO]")); /* Get varobj handle, if a valid var obj name was specified. */ - if (argc == 1 || argc == 3) - var = varobj_get_handle (argv[0]); + if (argc - oind == 1 || argc - oind == 3) + var = varobj_get_handle (argv[oind]); else - var = varobj_get_handle (argv[1]); + var = varobj_get_handle (argv[oind + 1]); - if (argc > 2) + if (argc - oind > 2) { from = atoi (argv[argc - 2]); to = atoi (argv[argc - 1]); @@ -403,10 +495,12 @@ mi_cmd_var_list_children (char *command, char **argv, int argc) to = -1; } + varobj_set_available_children_only (var, available_children_only); + children = varobj_list_children (var, &from, &to); ui_out_field_int (uiout, "numchild", to - from); - if (argc == 2 || argc == 4) - print_values = mi_parse_print_values (argv[0]); + if (argc - oind == 2 || argc - oind == 4) + print_values = mi_parse_print_values (argv[oind]); else print_values = PRINT_NO_VALUES; diff --git a/gdb/varobj.c b/gdb/varobj.c index 0e0be6c..1fd9fd2 100644 --- a/gdb/varobj.c +++ b/gdb/varobj.c @@ -119,6 +119,10 @@ struct varobj_dynamic can avoid that. */ int children_requested; + /* True if this varobj only includes available/collected objects in + its list of children. */ + int available_children_only; + /* The pretty-printer constructor. If NULL, then the default pretty-printer will be looked up. If None, then no pretty-printer will be installed. */ @@ -175,9 +179,9 @@ create_child_with_value (struct varobj *parent, int index, /* Utility routines */ -static struct varobj *new_variable (void); +static struct varobj *new_variable (int available_children_only); -static struct varobj *new_root_variable (void); +static struct varobj *new_root_variable (int available_children_only); static void free_variable (struct varobj *var); @@ -285,14 +289,14 @@ find_frame_addr_in_frame_chain (CORE_ADDR frame_addr) } struct varobj * -varobj_create (char *objname, - char *expression, CORE_ADDR frame, enum varobj_type type) +varobj_create (char *objname, char *expression, CORE_ADDR frame, + enum varobj_type type, int available_children_only) { struct varobj *var; struct cleanup *old_chain; /* Fill out a varobj structure for the (root) variable being constructed. */ - var = new_root_variable (); + var = new_root_variable (available_children_only); old_chain = make_cleanup_free_variable (var); if (expression != NULL) @@ -911,6 +915,23 @@ varobj_get_num_children (struct varobj *var) return var->num_children >= 0 ? var->num_children : 0; } +void +varobj_set_available_children_only (struct varobj *var, int available_only) +{ + if (var->dynamic->available_children_only != available_only) + { + /* If there are any children now, wipe them. */ + varobj_delete (var, NULL, /* children only */ 1); + var->num_children = -1; + var->dynamic->available_children_only = available_only; + + /* We're starting over, so get rid of any iterator. */ + varobj_iter_delete (var->dynamic->child_iter); + var->dynamic->child_iter = NULL; + varobj_clear_saved_item (var->dynamic); + } +} + /* Creates a list of the immediate children of a variable object; the return code is the number of such children or -1 on error. */ @@ -1071,7 +1092,8 @@ varobj_get_attributes (struct varobj *var) int varobj_is_dynamic_p (struct varobj *var) { - return var->dynamic->pretty_printer != NULL; + return (var->dynamic->pretty_printer != NULL + || var->dynamic->available_children_only); } char * @@ -2049,7 +2071,7 @@ create_child_with_value (struct varobj *parent, int index, struct varobj *child; char *childs_name; - child = new_variable (); + child = new_variable (parent->dynamic->available_children_only); /* NAME is allocated by caller. */ child->name = item->name; @@ -2086,8 +2108,9 @@ create_child_with_value (struct varobj *parent, int index, */ /* Allocate memory and initialize a new variable. */ + static struct varobj * -new_variable (void) +new_variable (int available_children_only) { struct varobj *var; @@ -2116,15 +2139,17 @@ new_variable (void) var->dynamic->pretty_printer = 0; var->dynamic->child_iter = 0; var->dynamic->saved_item = 0; + var->dynamic->available_children_only = available_children_only; return var; } /* Allocate memory and initialize a new root variable. */ + static struct varobj * -new_root_variable (void) +new_root_variable (int available_children_only) { - struct varobj *var = new_variable (); + struct varobj *var = new_variable (available_children_only); var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root)); var->root->lang_ops = NULL; @@ -2396,7 +2421,8 @@ value_of_root (struct varobj **var_handle, int *type_changed) char *old_type, *new_type; tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0, - USE_SELECTED_FRAME); + USE_SELECTED_FRAME, + var->dynamic->available_children_only); if (tmp_var == NULL) { return NULL; @@ -2756,7 +2782,8 @@ varobj_invalidate_iter (struct varobj *var, void *unused) /* Try to create a varobj with same expression. If we succeed replace the old varobj, otherwise invalidate it. */ tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0, - USE_CURRENT_FRAME); + USE_CURRENT_FRAME, + var->dynamic->available_children_only); if (tmp_var != NULL) { tmp_var->obj_name = xstrdup (var->obj_name); diff --git a/gdb/varobj.h b/gdb/varobj.h index 60ace6f..9beec79 100644 --- a/gdb/varobj.h +++ b/gdb/varobj.h @@ -225,7 +225,8 @@ const struct lang_varobj_ops ada_varobj_ops; extern struct varobj *varobj_create (char *objname, char *expression, CORE_ADDR frame, - enum varobj_type type); + enum varobj_type type, + int available_children_only); extern char *varobj_gen_name (void); @@ -310,6 +311,14 @@ extern int varobj_is_dynamic_p (struct varobj *var); extern struct cleanup *varobj_ensure_python_env (struct varobj *var); +/* Marks the varobj VAR as listing available children only or not, + depending on the boolean AVAILABLE_ONLY. If the + available-only-ness of the varobj changes compared to its present + state with this call, the varobj's current list of children is + deleted. */ +extern void varobj_set_available_children_only (struct varobj *var, + int available_only); + extern int varobj_default_value_is_changeable_p (struct varobj *var); extern int varobj_value_is_changeable_p (struct varobj *var); -- 1.7.7.6