Re: [1/2] Inspect extra signal information

[Pedro Alves <pedro@codesourcery.com>]

[-- Attachment #1: Type: text/plain, Size: 2002 bytes --]

On Monday 02 February 2009 21:04:34, Eli Zaretskii wrote:
> > From: Pedro Alves <pedro@codesourcery.com>
> > I don't see struct value documented in
> > the internals manual though.  What kind of detail do you require here?
> 
> Exactly the kind you described.

Great.

> > I'm thinking of adding a "Values" section somewhere, don't know
> > where yet.
> 
> The place doesn't matter much, since the internals manual is "work in
> progress", and looks more like a car crash than a concise document.
> 

:-)

There doesn't seem there's a good way to place it, since values
are used for many things, so I made it a new chapter.  I placed
it even before Stack Frames, because frame handling uses struct value.

> > @item @code{lval_computed}
> > 
> > These are values with arbitrary functions to handle reads and writes,
> 
> Please lose the empty line between the @item and its description.
> 

Done.

> > and "copy operators" and "destructors".  They allow creating
> 
> Please use ``this kind of quoting'' in Texinfo, not "this kind".
> 

Done.  ( it shows I didn't write that in emacs :-) )

> > described by the @code{struct lval_funcs} struture declared in
>                                             ^^^^^^^^
> A typo.
> 

Fixed.

> > @file{value.h} to the @code{allocate_computed_value} function.  An
> 
> What does it mean "declared in value.h to the allocate_computed_value
> function"?

It means I wrote a too long sentence, and lost sense somewhere along the
way.  :-)

"The creator of such a value specifies specialized read (...) callbacks (...)
to the @code{allocate_computed_value} function."

I've rewriten this.  I think it's clearer now.

> Perhaps add a few words describing `struct lval_funcs', or maybe just
> showing a simple example would be enough.

I've added an example.

> A couple of index entries for this section will also help.

I've added them.

> Thanks again for working on this.

Thanks for the speedy review.

Here's a proper patch.

Does it look OK?

-- 
Pedro Alves

[-- Attachment #2: lval_computed_docs.diff --]
[-- Type: text/x-diff, Size: 3614 bytes --]

2009-02-04  Pedro Alves  <pedro@codesourcery.com>

	* gdbint.texinfo (Values): New chapter.

---
 gdb/doc/gdbint.texinfo |   95 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)

Index: src/gdb/doc/gdbint.texinfo
===================================================================
--- src.orig/gdb/doc/gdbint.texinfo	2009-02-03 19:20:40.000000000 +0000
+++ src/gdb/doc/gdbint.texinfo	2009-02-05 01:11:31.000000000 +0000
@@ -76,6 +76,7 @@ as the mechanisms that adapt @value{GDBN
 * Algorithms::
 * User Interface::
 * libgdb::
+* Values::
 * Stack Frames::
 * Symbol Handling::
 * Language Support::
@@ -1834,6 +1835,100 @@ the query interface.  Each function is p
 builder.  The result of the query is constructed using that builder
 before the query function returns.
 
+@node Values
+@chapter Values
+@section Values
+
+@cindex values
+@cindex @code{value} structure
+@value{GDBN} uses @code{struct value}, or @dfn{values}, as an internal
+abstraction for the representation of a variety of inferior objects
+and @value{GDBN} convenience objects.
+
+Values have an associated @code{struct type}, that describes a virtual
+view of the raw data or object stored in or accessed through the
+value.
+
+A value is in addition descriminated by its lvalue-ness, given its
+@code{enum lval_type} enumeration type:
+
+@cindex @code{lval_type} enumeration, for values.
+@table @code
+@item @code{not_lval}
+This value is not an lval.  It can't be assigned to.
+
+@item @code{lval_memory}
+This value represents an object in memory.
+
+@item @code{lval_register}
+This value represents an object that lives in a register.
+
+@item @code{lval_internalvar}
+Represents the value of an internal variable.
+
+@item @code{lval_internalvar_component}
+Represents part of a gdb internal variable.  E.g., a structure field.
+
+@cindex computed values
+@item @code{lval_computed}
+These are ``computed'' values.  They allow creating specialized value
+objects for specific purposes, all abstracted way from the the core
+value support code.  The creator of such a value writes specialized
+functions to handle the reading and writing to/from the value's
+backend data, and optionally, a ``copy operator'' and a
+``destructor''.
+
+Pointers to these functions are stored in a @code{struct lval_funcs}
+instance (declared in @file{value.h}), and passed to the
+@code{allocate_computed_value} function, as in the example below.
+
+@smallexample
+static void
+nil_value_read (struct value *v)
+@{
+  /* This callback reads data from some backend, and stores it in V.
+     In this case, we always read null data.  You'll want to fill in
+     something more interesting.  */
+
+  memset (value_contents_all_raw (v),
+          value_offset (v),
+          TYPE_LENGTH (value_type (v)));
+@}
+
+static void
+nil_value_write (struct value *v, struct value *fromval)
+@{
+  /* Takes the data from FROMVAL and stores it in the backend of V.  */
+
+  to_oblivion (value_contents_all_raw (fromval),
+               value_offset (v),
+               TYPE_LENGTH (value_type (fromval)));
+@}
+
+static struct lval_funcs nil_value_funcs =
+  @{
+    nil_value_read,
+    nil_value_write
+  @};
+
+struct value *
+make_nil_value (void)
+@{
+   struct type *type;
+   struct value *v;
+
+   type = make_nils_type ();
+   v = allocate_computed_value (type, &nil_value_funcs, NULL);
+
+   return v;
+@}
+@end smallexample
+
+See the implementation of the @code{$_siginfo} convenience variable in
+@file{infrun.c} as a real example use of lval_computed.
+
+@end table
+
 @node Stack Frames
 @chapter Stack Frames