Re: embedded list v2

Hi,

On Sunday, September 16, 2012 04:23:14 PM Andres Freund wrote:
> What do you think about something like:
> 
> typedef struct dlist_iter
> {
> 	/*
> 	 * Use a union with equivalent storage as dlist_node to make it possible
> to * initialize the struct inside a macro without multiple evaluation. */
> 	union {
> 		struct {
> 			dlist_node *cur;
> 			dlist_node *end;
> 		};
> 		dlist_node init;
> 	};
> } dlist_iter;
> 
> typedef struct dlist_mutable_iter
> {
> 	union {
> 		struct {
> 			dlist_node *cur;
> 			dlist_node *end;
> 		};
> 		dlist_node init;
> 	};
> 	dlist_node *next;
> } dlist_mutable_iter;
> 
> #define dlist_iter_foreach(iter, ptr)									     \
> 	for (iter.init = (ptr)->head; iter.cur != iter.end;                      \
> 	     iter.cur = iter.cur->next)
> 
> #define dlist_iter_foreach_modify(iter, ptr)								 
\
> 	for (iter.init = (ptr)->head, iter.next = iter.cur->next;                \
> 	     iter.cur != iter.end                                                \
> 	     iter.cur = iter.next, iter.next = iter.cur->next)
> 
> With that and some trivial changes *all* multiple evaluation possibilities
> are gone.
> 
> (_iter_ in there would go, thats just so I can have both in the same file
> for now).

I am thinking whether a macro like:

#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#define assert_compatible_types(a, b) _Static_assert(            \
		__builtin_types_compatible_p(a, __typeof__ (b) ), \
		"variable `" #b "` is not compatible to type `" #a "`" )
#else
#define assert_compatible_types(a, b) (void)0
#endif

used like:

#define dlist_iter_foreach(iter, ptr)									     \
	assert_compatible_types(dlist_iter, iter);                               \
	for (iter.init = (ptr)->head; iter.cur != iter.end;                      \
	     iter.cur = iter.cur->next)

would be useful.

If you use the wrong type you get an error like:

error: static assertion failed: "variable `iter` is not compatible to type 
`dlist_iter`"

Do people think this is something worthwile for some of the macros in pg? At 
times the compiler errors that get generated in larger macros can be a bit 
confusing and something like that would make it easier to see the originating 
error.

I found __builtin_types_compatible while perusing the gcc docs to find whether 
there is something like __builtin_constant_p for checking the pureness of an 
expression ;)

Andres
-- 
 Andres Freund	                   http://www.2ndQuadrant.com/
 PostgreSQL Development, 24x7 Support, Training & Services