Revise struct names in examples in comments to end with _t

/** Macro: yield a pointer to the field at position <b>off</b> within the

 * structure <b>st</b>.  Example:

 * <pre>

 *   struct a { int foo; int bar; } x;

 *   ptrdiff_t bar_offset = offsetof(struct a, bar);

 *   struct a_t { int foo; int bar; } x;

 *   ptrdiff_t bar_offset = offsetof(struct a_t, bar);

 *   int *bar_p = STRUCT_VAR_P(&x, bar_offset);

 *   *bar_p = 3;

 * </pre>

/** Macro: yield a pointer to an enclosing structure given a pointer to

 * a substructure at offset <b>off</b>. Example:

 * <pre>

 *   struct base { ... };

 *   struct subtype { int x; struct base b; } x;

 *   struct base *bp = &x.base;

 *   struct *sp = SUBTYPE_P(bp, struct subtype, b);

 *   struct base_t { ... };

 *   struct subtype_t { int x; struct base_t b; } x;

 *   struct base_t *bp = &x.base;

 *   struct *sp = SUBTYPE_P(bp, struct subtype_t, b);

 * </pre>

 */

#define SUBTYPE_P(p, subtype, basemember) \

 * To enable a type to have handles, add a HANDLE_ENTRY() field in its

 * definition, as in:

 *

 *     struct walrus {

 *         HANDLE_ENTRY(wlr, walrus);

 *     struct walrus_t {

 *         HANDLE_ENTRY(wlr, walrus_t);

 *         // ...

 *     };

 *

 * And invoke HANDLE_DECL(wlr, walrus, [static]) to declare the handle

 * And invoke HANDLE_DECL(wlr, walrus_t, [static]) to declare the handle

 * manipulation functions (typically in a header):

 *

 *     // opaque handle to walrus.

 *     typedef struct wlr_handle_t wlr_handle_t;

 *

 *     // make a new handle

 *     struct wlr_handle_t *wlr_handle_new(struct walrus *);

 *     struct wlr_handle_t *wlr_handle_new(struct walrus_t *);

 *

 *     // release a handle

 *     void wlr_handle_free(wlr_handle_t *);

 *

 *     // return the pointed-to walrus, or NULL.

 *     struct walrus *wlr_handle_get(wlr_handle_t *).

 *     struct walrus_t *wlr_handle_get(wlr_handle_t *).

 *

 *     // call this function when you're about to free the walrus;

 *     // it invalidates all handles. (IF YOU DON'T, YOU WILL HAVE

 *     // DANGLING REFERENCES)

 *     void wlr_handles_clear(struct walrus *);

 *     void wlr_handles_clear(struct walrus_t *);

 *

 * Finally, use HANDLE_IMPL() to define the above functions in some

 * appropriate C file: HANDLE_IMPL(wlr, walrus, [static])

 * appropriate C file: HANDLE_IMPL(wlr, walrus_t, [static])

 *

 **/

* If you want to define a distribution type, define a canonical set of

* operations and define a type-specific initializer element like so:

*

*     struct foo {

*     struct foo_t {

*       struct dist_t base;

*       int omega;

*       double tau;

*

*     struct dist_ops_t foo_ops = ...;

*

*     #define FOO(OBJ) DIST_BASE_TYPED(&foo_ops, OBJ, struct foo)

*     #define FOO(OBJ) DIST_BASE_TYPED(&foo_ops, OBJ, struct foo_t)

*

* Then users can do:

*

*     struct foo mydist = {

*     struct foo_t mydist = {

*       FOO(mydist),

*       .omega = ...,

*       .tau = ...,

*

* If you accidentally write

*

*     struct bar mydist = {

*     struct bar_t mydist = {

*       FOO(mydist),

*       ...

*     };