"ra************ *******@gmail.c om" <ra************ *******@gmail.c omwrote:

# i was reading soemthing about Lvalues Rvalues and modifiable

# Lvalues....

# i am confused now...

# like for eg

# int *y , x ;

# y = &x ;

# in the second is x a lvalue or rvalue

# any pointers on some good reading on lvalues and rvalues on the web ??

# thanks in advance

Unfortunately except for Algol 68 and assmebly language,

variableness is left out of type systems, requiring instead

much verbal handwaving that could be more precise.

Borrowing & from C++ with restriction that a reference type

cannot be inside any other type, then when you declare a

scalar and array,

T v,w[n],*x;

v has type (&T), w has type (*T), and x has type (&*T).

Then the pointer/variable operator types are

v = e

v is coerceable to type &T

and e is coerceable to type T

and (v=e) is type T

*x

x is coercecable to *T

and *x is type &T

&v

v is coercecable to &T

and &v is type *T

s.f

If s is coercable to &T and f has nonreference type S,

(s.f) has type &S [endowed with subnames in Algol 68].

If s is not coercable to T and f has nonreference type S,

(s.f) has type S.

LOAD(v) is an implicit operator

v is coerceable to &T

and LOAD(v) is type T

Expressions q in the language is then applied to one of two implicit

functions LVALUE(q) or RVALUE(q)

LVALUE(q) = q and q must have type &T

RVALUE(q) = LOAD(q) if q has type &T

RVALUE(q) = q if q has type T which is not a reference type

The pointer/variable operator implicits are

LVALUE(v) = RVALUE(e)

* RVALUE(x)

& LVALUE(x)

s . f - There is no implicit on s.

A variable by itself has its declared type, T or &T.

All other expressions are

prefixop RVALUE(operand)

RVALUE(leftoper and) infixop RVALUE(rightope rand)

RVALUE(predicat e) ? RVALUE(truebran ch) : RVALUE(falsebra nch)

GCC has an alternate rule for ?: - there is no implicit RVALUE or

LVALUE on the branches except they must be coerceable to a balanced

type T, T may be a reference type.

(p?v:*x) = e

LVALUE((RVALUE( p) ? v : *RVALUE(x))) = RVALUE(e)

with the types LVALUE(RVALUE(i nt) ? &T : *RVALUE(&*T)) = RVALUE(S)

LVALUE(RVALUE(i nt) ? &T : *(LOAD(&*T))) = S

LVALUE(RVALUE(i nt) ? &T : *(*T)) = S

LVALUE(RVALUE(i nt) ? &T : &T) = S

LVALUE(&T) = S

&T = S

and if S is coerceable to T, the assignment is valid in GCC,

but in ANSI C, the types are T=S which is invalid.

--

SM Ryan

http://www.rawbw.com/~wyrmwif/
But I do believe in this.