This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH] MI: lvalues and variable_editable


 > > In that case for such a varobj, var->value == NULL must indicate that the
 > > memory was inaccessible at the _last_ update, or creation, and it may no
 > > longer be inaccessible.  Describing it as "noneditable" may then be a bit
 > > misleading.
 > 
 > The next time it's -var-update'd it may get a new value; presumably
 > the IDE does that periodically.

I guess, in that respect it's no different to -var-evaluate-expression.  Here's
my latest patch for varobj.c.  I've removed the test for var->value != NULL in
varobj_set_value as it's already in varobj_editable_p.  I've also moved the
test for var->root->is_valid from varobj_get_attributes to varobj_editable_p.
This patch would require two x two changes to the testsuite:

FAIL: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr editable
FAIL: gdb.mi/mi2-var-child.exp: is weird.int_ptr_ptr.*int_ptr_ptr.**int_ptr_ptr 
editable

editable -> noneditable

likewise for mi-var-child.exp

There's also an independent change to mi_cmd_var_assign in mi-cmd-var.c that I
think makes it simpler.

-- 
Nick                                           http://www.inet.net.nz/~nickrob


2007-11-03  Nick Roberts  <nickrob@snap.net.nz>

	* varobj.c (c_variable_editable, cplus_variable_editable)
	(java_variable_editable, variable_editable): Delete.
	(varobj_editable_p): Replace above functions with one language
	independent function.  Check for an lvalue.
	(varobj_get_attributes, varobj_set_value): Use varobj_editable_p.
	(struct language_specific): Delete variable_editable field.

	* mi-cmd-var.c (mi_cmd_var_assign): Simplify.


*** varobj.c	27 Oct 2007 09:51:19 +1300	1.96
--- varobj.c	03 Nov 2007 21:50:19 +1300	
*************** static struct value *value_of_root (stru
*** 221,228 ****
  
  static struct value *value_of_child (struct varobj *parent, int index);
  
- static int variable_editable (struct varobj *var);
- 
  static char *my_value_of_variable (struct varobj *var);
  
  static char *value_get_print_value (struct value *value,
--- 221,226 ----
*************** static struct value *c_value_of_child (s
*** 248,255 ****
  
  static struct type *c_type_of_child (struct varobj *parent, int index);
  
- static int c_variable_editable (struct varobj *var);
- 
  static char *c_value_of_variable (struct varobj *var);
  
  /* C++ implementation */
--- 246,251 ----
*************** static struct value *cplus_value_of_chil
*** 270,277 ****
  
  static struct type *cplus_type_of_child (struct varobj *parent, int index);
  
- static int cplus_variable_editable (struct varobj *var);
- 
  static char *cplus_value_of_variable (struct varobj *var);
  
  /* Java implementation */
--- 266,271 ----
*************** static struct value *java_value_of_child
*** 290,297 ****
  
  static struct type *java_type_of_child (struct varobj *parent, int index);
  
- static int java_variable_editable (struct varobj *var);
- 
  static char *java_value_of_variable (struct varobj *var);
  
  /* The language specific vector */
--- 284,289 ----
*************** struct language_specific
*** 324,332 ****
    /* The type of the INDEX'th child of PARENT. */
    struct type *(*type_of_child) (struct varobj * parent, int index);
  
-   /* Is VAR editable? */
-   int (*variable_editable) (struct varobj * var);
- 
    /* The current value of VAR. */
    char *(*value_of_variable) (struct varobj * var);
  };
--- 316,321 ----
*************** static struct language_specific language
*** 343,349 ****
     c_value_of_root,
     c_value_of_child,
     c_type_of_child,
-    c_variable_editable,
     c_value_of_variable}
    ,
    /* C */
--- 332,337 ----
*************** static struct language_specific language
*** 356,362 ****
     c_value_of_root,
     c_value_of_child,
     c_type_of_child,
-    c_variable_editable,
     c_value_of_variable}
    ,
    /* C++ */
--- 344,349 ----
*************** static struct language_specific language
*** 369,375 ****
     cplus_value_of_root,
     cplus_value_of_child,
     cplus_type_of_child,
-    cplus_variable_editable,
     cplus_value_of_variable}
    ,
    /* Java */
--- 356,361 ----
*************** static struct language_specific language
*** 382,388 ****
     java_value_of_root,
     java_value_of_child,
     java_type_of_child,
-    java_variable_editable,
     java_value_of_variable}
  };
  
--- 368,373 ----
*************** varobj_create (char *objname,
*** 523,529 ****
  	  select_frame (fi);
  	}
  
!       /* We definitively need to catch errors here.
           If evaluate_expression succeeds we got the value we wanted.
           But if it fails, we still go on with a call to evaluate_type()  */
        if (!gdb_evaluate_expression (var->root->exp, &value))
--- 508,514 ----
  	  select_frame (fi);
  	}
  
!       /* We definitely need to catch errors here.
           If evaluate_expression succeeds we got the value we wanted.
           But if it fails, we still go on with a call to evaluate_type()  */
        if (!gdb_evaluate_expression (var->root->exp, &value))
*************** varobj_get_attributes (struct varobj *va
*** 856,862 ****
  {
    int attributes = 0;
  
!   if (var->root->is_valid && variable_editable (var))
      /* FIXME: define masks for attributes */
      attributes |= 0x00000001;	/* Editable */
  
--- 841,847 ----
  {
    int attributes = 0;
  
!   if (varobj_editable_p (var))
      /* FIXME: define masks for attributes */
      attributes |= 0x00000001;	/* Editable */
  
*************** varobj_set_value (struct varobj *var, ch
*** 887,940 ****
    struct value *value;
    int saved_input_radix = input_radix;
  
!   if (var->value != NULL && variable_editable (var))
!     {
!       char *s = expression;
!       int i;
  
!       input_radix = 10;		/* ALWAYS reset to decimal temporarily */
!       exp = parse_exp_1 (&s, 0, 0);
!       if (!gdb_evaluate_expression (exp, &value))
! 	{
! 	  /* We cannot proceed without a valid expression. */
! 	  xfree (exp);
! 	  return 0;
! 	}
! 
!       /* All types that are editable must also be changeable.  */
!       gdb_assert (varobj_value_is_changeable_p (var));
! 
!       /* The value of a changeable variable object must not be lazy.  */
!       gdb_assert (!value_lazy (var->value));
! 
!       /* Need to coerce the input.  We want to check if the
! 	 value of the variable object will be different
! 	 after assignment, and the first thing value_assign
! 	 does is coerce the input.
! 	 For example, if we are assigning an array to a pointer variable we
! 	 should compare the pointer with the the array's address, not with the
! 	 array's content.  */
!       value = coerce_array (value);
! 
!       /* The new value may be lazy.  gdb_value_assign, or 
! 	 rather value_contents, will take care of this.
! 	 If fetching of the new value will fail, gdb_value_assign
! 	 with catch the exception.  */
!       if (!gdb_value_assign (var->value, value, &val))
! 	return 0;
!      
!       /* If the value has changed, record it, so that next -var-update can
! 	 report this change.  If a variable had a value of '1', we've set it
! 	 to '333' and then set again to '1', when -var-update will report this
! 	 variable as changed -- because the first assignment has set the
! 	 'updated' flag.  There's no need to optimize that, because return value
! 	 of -var-update should be considered an approximation.  */
!       var->updated = install_new_value (var, val, 0 /* Compare values. */);
!       input_radix = saved_input_radix;
!       return 1;
      }
  
!   return 0;
  }
  
  /* Returns a malloc'ed list with all root variable objects */
--- 872,920 ----
    struct value *value;
    int saved_input_radix = input_radix;
  
!   char *s = expression;
!   int i;
  
!   input_radix = 10;		/* ALWAYS reset to decimal temporarily */
!   exp = parse_exp_1 (&s, 0, 0);
!   if (!gdb_evaluate_expression (exp, &value))
!     {
!       /* We cannot proceed without a valid expression. */
!       xfree (exp);
!       return 0;
      }
  
!   /* All types that are editable must also be changeable.  */
!   gdb_assert (varobj_value_is_changeable_p (var));
! 
!   /* The value of a changeable variable object must not be lazy.  */
!   gdb_assert (!value_lazy (var->value));
! 
!   /* Need to coerce the input.  We want to check if the
!      value of the variable object will be different
!      after assignment, and the first thing value_assign
!      does is coerce the input.
!      For example, if we are assigning an array to a pointer variable we
!      should compare the pointer with the the array's address, not with the
!      array's content.  */
!   value = coerce_array (value);
! 
!   /* The new value may be lazy.  gdb_value_assign, or 
!      rather value_contents, will take care of this.
!      If fetching of the new value will fail, gdb_value_assign
!      with catch the exception.  */
!   if (!gdb_value_assign (var->value, value, &val))
!     return 0;
!      
!   /* If the value has changed, record it, so that next -var-update can
!      report this change.  If a variable had a value of '1', we've set it
!      to '333' and then set again to '1', when -var-update will report this
!      variable as changed -- because the first assignment has set the
!      'updated' flag.  There's no need to optimize that, because return value
!      of -var-update should be considered an approximation.  */
!   var->updated = install_new_value (var, val, 0 /* Compare values. */);
!   input_radix = saved_input_radix;
!   return 1;
  }
  
  /* Returns a malloc'ed list with all root variable objects */
*************** value_of_child (struct varobj *parent, i
*** 1801,1814 ****
    return value;
  }
  
- /* Is this variable editable? Use the variable's type to make
-    this determination. */
- static int
- variable_editable (struct varobj *var)
- {
-   return (*var->root->lang->variable_editable) (var);
- }
- 
  /* GDB already has a command called "value_of_variable". Sigh. */
  static char *
  my_value_of_variable (struct varobj *var)
--- 1781,1786 ----
*************** value_get_print_value (struct value *val
*** 1840,1845 ****
--- 1812,1847 ----
    return thevalue;
  }
  
+ int
+ varobj_editable_p (struct varobj *var)
+ {
+   struct type *type;
+   struct value *value;
+ 
+   if (CPLUS_FAKE_CHILD (var))
+     return 0;
+ 
+   if (!(var->root->is_valid && var->value && VALUE_LVAL(var->value)))
+     return 0;
+ 
+   type = get_value_type (var);
+ 
+   switch (TYPE_CODE (type))
+     {
+     case TYPE_CODE_STRUCT:
+     case TYPE_CODE_UNION:
+     case TYPE_CODE_ARRAY:
+     case TYPE_CODE_FUNC:
+     case TYPE_CODE_METHOD:
+       return 0;
+       break;
+ 
+     default:
+       return 1;
+       break;
+     }
+ }
+ 
  /* Return non-zero if changes in value of VAR
     must be detected and reported by -var-update.
     Return zero is -var-update should never report
*************** c_type_of_child (struct varobj *parent, 
*** 2212,2236 ****
    return type;
  }
  
- static int
- c_variable_editable (struct varobj *var)
- {
-   switch (TYPE_CODE (get_value_type (var)))
-     {
-     case TYPE_CODE_STRUCT:
-     case TYPE_CODE_UNION:
-     case TYPE_CODE_ARRAY:
-     case TYPE_CODE_FUNC:
-     case TYPE_CODE_METHOD:
-       return 0;
-       break;
- 
-     default:
-       return 1;
-       break;
-     }
- }
- 
  static char *
  c_value_of_variable (struct varobj *var)
  {
--- 2214,2219 ----
*************** cplus_type_of_child (struct varobj *pare
*** 2602,2616 ****
    return type;
  }
  
- static int
- cplus_variable_editable (struct varobj *var)
- {
-   if (CPLUS_FAKE_CHILD (var))
-     return 0;
- 
-   return c_variable_editable (var);
- }
- 
  static char *
  cplus_value_of_variable (struct varobj *var)
  {
--- 2585,2590 ----
*************** java_type_of_child (struct varobj *paren
*** 2694,2705 ****
    return cplus_type_of_child (parent, index);
  }
  
- static int
- java_variable_editable (struct varobj *var)
- {
-   return cplus_variable_editable (var);
- }
- 
  static char *
  java_value_of_variable (struct varobj *var)
  {
--- 2668,2673 ----


*** mi-cmd-var.c	03 Nov 2007 22:17:04 +1300	1.40
--- mi-cmd-var.c	03 Nov 2007 12:24:24 +1300	
*************** mi_cmd_var_assign (char *command, char *
*** 512,527 ****
      error (_("mi_cmd_var_assign: Variable object not found"));
  
    /* FIXME: define masks for attributes */
!   if (!(varobj_get_attributes (var) & 0x00000001))
      error (_("mi_cmd_var_assign: Variable object is not editable"));
  
!   expression = xstrdup (argv[1]);
! 
!   if (!varobj_set_value (var, expression))
!     error (_("mi_cmd_var_assign: Could not assign expression to variable object"));
  
!   ui_out_field_string (uiout, "value", varobj_get_value (var));
!   return MI_CMD_DONE;
  }
  
  enum mi_cmd_result
--- 512,529 ----
      error (_("mi_cmd_var_assign: Variable object not found"));
  
    /* FIXME: define masks for attributes */
!   if (!varobj_editable_p (var))
      error (_("mi_cmd_var_assign: Variable object is not editable"));
+   else
+     {
+       expression = xstrdup (argv[1]);
  
!       if (!varobj_set_value (var, expression))
! 	error (_("mi_cmd_var_assign: Could not assign expression to variable object"));
  
!       ui_out_field_string (uiout, "value", varobj_get_value (var));
!       return MI_CMD_DONE;
!     }
  }
  
  enum mi_cmd_result


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]