On Thu, 2007-07-05 at 17:43 +0100, Al Viro wrote:
> On Thu, Jul 05, 2007 at 08:36:35AM -0700, Josh Triplett wrote:
> > Wow. Insane. So these all declare the same type:
> > __attribute__((foo)) T *v;
> > T __attribute__((foo)) *v;
> > T *__attribute__((foo)) v;
> > ? Specifically, they point to a foo-T, for convenient shooting?
> They all give you foo-pointer-to-T.
> T (__attribute__((foo)) *v);
> would give pointer-to-foo-T.
Doesn't that do exactly what we want, then? If we say
T __attribute__((noderef)) *v;
, we want a noderef-pointer-to-T, not a pointer-to-noderef-T. noderef
should modify a pointer.
> > context also represents a qualifier; the position of the qualifier should
> > determine things like whether you want to enforce the context when you access
> > a pointer or dereference a pointer.
> Since __context__ is (sparse-only) keyword, we are not constrained by
> anything anyway.
No, I mean __attribute__((context(...))), which means something
different. __context__() works as a statement statement changing the
context. __attribute__((context(...))) works as an attribute modifying
a type to say that it requires a given context, and that
accessing/calling it changes the context. Somewhat of an odd
distinction, but sparse currently works that way.
> > > Frankly, I would rather add a new primitive (__qualifier__) mirroring the
> > > __attribute__, but acting like real qualifiers do. And switched the
> > > noderef et.al. to it.
> > Something like that sounds vaguely reasonable. It should allow the same set
> > of attributes, and just change what they apply to. To use your example,
> > T __qualifier__((foo)) *v;
> > and
> > T (__attribute__((foo)) *v);
> > would mean the same thing.
> Yup, except that it would not accept storage-class-like attributes (e.g.
So, to clarify what you mean by storage-class-like: __qualifier__ would
accept all attributes that modify a *type* rather than a *declaration*.
> And yes, __qualifier__((context(...))) probably might
> be a replacement for __context__, to reduce the number of primitives.
No, see above. __context__ works as a statement, not as a way to modify
That said, "calling this function requires this context or changes the
context" and "accessing this variable requires this context or changes
the context" may represent different types of attributes. I don't know.
- Josh Triplett
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[Index of Archives]
[Video 4 Linux]
[Linux for the blind]