🚀 go-pugleaf

bhoughto@sedona.intel.com (Blair P. Houghton) writes:
>I'm trying to develop a good definition, and it's come
>down to a few expression forms.  The important
>thing to remember is that it's the value, not the
>identifier or the location, that is being "used."
>	if ( foo ) ...;		/* uses `foo' */
>	foo;			/* does not use `foo' */

I'm not even sure that I know what you want to mean by "use".  The "if"
statement there accesses the object named by the identifier "foo" (assuming 
that "foo" is declared as designating an object); the expression statement
below it accesses the object named by the identifier "foo" and then discards
the value of that object.  One would think that if "foo" were declared as
"volatile", the object designated by "foo" here *must* be accessed in a
running program.  The definitive answer, if one can call it that, is to be
found in section 3.5.3 "Type Qualifiers" of the ANSI standard:  "What
constitutes an access to an object that has volatile-qualified type is
implementation-defined."  Perhaps, then, an implementation has the license
to define that

	foo;

does not access the object referred to by foo, and/or that

	foo = x;

does, though in the first case I *think* that's stretching the license too far.
Remember that a strictly conforming program cannot use "volatile"; it is not
a guarantee of portability, it is a "portable" way to beg for mercy :-).

Others have hammered the "non-modifiable lvalue" answer to death; I'll just
point out that it would have been glaringly obvious had you read the section
entitled "Lvalues and Function Designators"...