«

Thoughts, comments?

#ifdef HAVE_TYPEOF

/*
* Can use arbitrary expressions
*/
#define alignof(t) \
((sizeof (t) > 1)? offsetof(struct { char c; typeof(t) x; }, x) : 1)

#else

/*
* Can only use types
*/
#define alignof(t) \
((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)

#endif

William Ahern <> writes:

> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)

I'm not certain whether that's portably correct or not, but I
must say that, regardless, it's remarkably clever.
--
"What is appropriate for the master is not appropriate for the novice.
You must understand the Tao before transcending structure."
--The Tao of Programming

William Ahern <> writes:
> Thoughts, comments?
>
> #ifdef HAVE_TYPEOF
>
> /*
> * Can use arbitrary expressions
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; typeof(t) x; }, x) : 1)
>
> #else
>
> /*
> * Can only use types
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)
>
> #endif

I don't see a problem with it, but I don't think the test for
sizeof(t) is necessary:

#define alignof(t) \
offsetof(struct { char c; t x; }, x)

--
Keith Thompson (The_Other_Keith) kst- <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

William Ahern wrote:
> Thoughts, comments?
> ...
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)

Looks okay, but realise that whilst it will return a suitable
alignment,
it may not return the minimum alignment. For instance, a 4 byte
int may only require two byte alignment on a given machine, but
because of compiler dependant padding settings, alignof might
return 4 (or even 8 etc...).

Your test if sizeof(t) > 1 would indicate that you have already
encountered such an issue with char in that regard.

If you're paranoid and you want a little more precision, you might
want to take the minimum of your expression and sizeof(t)...

#define min(a,b) ((a) < (b) ? (a) : (b))

#define simple_alignof(t) \
(sizeof (t) > 1 ? offsetof(struct { char c; t x; }, x) : 1)

#define alignof(t) min(sizeof(t), simple_alignof(t))

--
Peter

Ben Pfaff wrote:
> William Ahern <> writes:
>
>> #define alignof(t) \
>> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)
>
> I'm not certain whether that's portably correct or not, but I
> must say that, regardless, it's remarkably clever.

And it should be efficient, generating a simple constant. This
should have appeared in the making fatal assumptions thread, where
just that sort of problem led to various assumptions.

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson
More details at: <http://cfaj.freeshell.org/google/>
Also see <http://www.safalra.com/special/googlegroupsreply/>

William Ahern wrote:
> Thoughts, comments?
>
> #ifdef HAVE_TYPEOF
>
> /*
> * Can use arbitrary expressions
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; typeof(t) x; },
> x) : 1)
>
> #else
>
> /*
> * Can only use types
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)
>
> #endif

Could someone provide an example of how to use this please - and the typeof
macro if poss?


--
==============
Not a pedant
==============

On 2006-03-09, pemo <> wrote:
> Could someone provide an example of how to use this please - and the typeof
> macro if poss?

typeof isn't a macro, it's a non-standard keyword. That's why it's
guarded by a HAVE_TYPEOF macro.

Keith Thompson wrote:

> I don't see a problem with it, but I don't think the test for
> sizeof(t) is necessary:
>
> #define alignof(t) \
> offsetof(struct { char c; t x; }, x)
>
> --

Isn''t the test needed because, with the above, alignof(char) will
yield 2?

REH

William Ahern wrote:
> Thoughts, comments?
>
> #ifdef HAVE_TYPEOF
>
> /*
> * Can use arbitrary expressions
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; typeof(t) x; }, x) : 1)
>
> #else
>
> /*
> * Can only use types
> */
> #define alignof(t) \
> ((sizeof (t) > 1)? offsetof(struct { char c; t x; }, x) : 1)
>
> #endif

I think it's very clever. I am wondering, though, what is the
necessity of typeof? I assume that if it is available, you want to use
it. That would imply it somehow makes its form of alignof "better" but
I cannot tell why. please explain.

REH

"REH" <> writes:
> Keith Thompson wrote:
>
>> I don't see a problem with it, but I don't think the test for
>> sizeof(t) is necessary:
>>
>> #define alignof(t) \
>> offsetof(struct { char c; t x; }, x)
>>
> Isn''t the test needed because, with the above, alignof(char) will
> yield 2?

Nope. Given struct { char c; char x; }, c has offset 0 and x has
offset 1 (unless the compiler decides to insert padding between c and
x).

--
Keith Thompson (The_Other_Keith) kst- <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.