2009-02-13 Pierre Muller <muller@ics.u-strasbg.fr>

[binutils-gdb.git] / gdb / value.h

diff --git a/gdb/value.h b/gdb/value.h
index 9a11190957be5ee74b5242e5ed3d43002bdd9a18..aa43365efe575b316515b26a63ce71e20f7a9e50 100644 (file)
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -142,6 +142,60 @@ extern void set_value_pointed_to_offset (struct value *value, int val);
 extern int value_embedded_offset (struct value *value);
 extern void set_value_embedded_offset (struct value *value, int val);
 
+/* For lval_computed values, this structure holds functions used to
+   retrieve and set the value (or portions of the value).
+
+   For each function, 'V' is the 'this' pointer: an lval_funcs
+   function F may always assume that the V it receives is an
+   lval_computed value, and has F in the appropriate slot of its
+   lval_funcs structure.  */
+
+struct lval_funcs
+{
+  /* Fill in VALUE's contents.  This is used to "un-lazy" values.  If
+     a problem arises in obtaining VALUE's bits, this function should
+     call 'error'.  */
+  void (*read) (struct value *v);
+
+  /* Handle an assignment TOVAL = FROMVAL by writing the value of
+     FROMVAL to TOVAL's location.  The contents of TOVAL have not yet
+     been updated.  If a problem arises in doing so, this function
+     should call 'error'.  */
+  void (*write) (struct value *toval, struct value *fromval);
+
+  /* Return a duplicate of VALUE's closure, for use in a new value.
+     This may simply return the same closure, if VALUE's is
+     reference-counted or statically allocated.
+
+     This may be NULL, in which case VALUE's closure is re-used in the
+     new value.  */
+  void *(*copy_closure) (struct value *v);
+
+  /* Drop VALUE's reference to its closure.  Maybe this frees the
+     closure; maybe this decrements a reference count; maybe the
+     closure is statically allocated and this does nothing.
+
+     This may be NULL, in which case no action is taken to free
+     VALUE's closure.  */
+  void (*free_closure) (struct value *v);
+};
+
+/* Create a computed lvalue, with type TYPE, function pointers FUNCS,
+   and closure CLOSURE.  */
+
+extern struct value *allocate_computed_value (struct type *type,
+                                              struct lval_funcs *funcs,
+                                              void *closure);
+
+/* If VALUE is lval_computed, return its lval_funcs structure.  */
+
+extern struct lval_funcs *value_computed_funcs (struct value *value);
+
+/* If VALUE is lval_computed, return its closure.  The meaning of the
+   returned value depends on the functions VALUE uses.  */
+
+extern void *value_computed_closure (struct value *value);
+
 /* If zero, contents of this value are in the contents field.  If
    nonzero, contents are in inferior.  If the lval field is lval_memory,
    the contents are in inferior memory at location.address plus offset.
@@ -251,11 +305,14 @@ extern struct value *coerce_array (struct value *value);
 /* Internal variables (variables for convenience of use of debugger)
    are recorded as a chain of these structures.  */
 
+typedef struct value * (*internalvar_make_value) (struct internalvar *);
+
 struct internalvar
 {
   struct internalvar *next;
   char *name;
   struct value *value;
+  internalvar_make_value make_value;
   int endian;
 };
 
@@ -480,6 +537,9 @@ extern struct internalvar *lookup_only_internalvar (char *name);
 
 extern struct internalvar *create_internalvar (char *name);
 
+extern struct internalvar *
+  create_internalvar_type_lazy (char *name, internalvar_make_value fun);
+
 extern struct internalvar *lookup_internalvar (char *name);
 
 extern int value_equal (struct value *arg1, struct value *arg2);