Re: Top 10 most common hard skills listed on resumes...

On 29/08/2024 23:03, Keith Thompson wrote:

Bart <bc@freeuk.com> writes:

On 29/08/2024 21:30, Keith Thompson wrote:

Bart <bc@freeuk.com> writes:
[...]

So what exactly is different about the LHS and RHS here:
>
     A = A;

The RHS is evaluated to determine the current value stored in the
object
named A.  The LHS is evaluated to determine the object that's designated
by the name A; its current value is irrelevant.

>
Sure, but the same thing happens on both sides: one ends up performing
a Read via that Lvalue, and the other does a Write via that Lvalue.

 The read is done by converting the lvalue to its value, which is not an
lvalue.  Please read the discussion of "lvalue conversion" in the C
standard.
 

In C terms, the RHS undergoes *lvalue conversion*, where an expression
that's an lvalue is converted to the value stored in the designated
object.  The LHS does not undergo lvalue conversion.
>

(In BLISS, doing the same thing requires 'A = .A' AIUI; while 'A = A'
is also valid, there is a hidden mismatch in indirection levels
between left and right. It is asymmetric while in C it is symmetric,
although seem to disagree on that latter point.)

Because BLISS, unlike C, does not have implicit lvalue conversion;
the
prefix "." operator performs explicit lvalue conversion.  I presume the
"." operator isn't specific to assignments.

>
But it must have that conversion on the LHS, otherwise it's A's
address that is written to rather than its value, which doesn't make
sense. That's why I said it was asymmetric; the RHS needs an explicit
operator, the LHS doesn't.

 No, the address isn't written.  The object is written.
 The RHS evaluation determines the value currently stored in the object.
The LHS evaluation does not.  That's the asymmetry.
 In BLISS, the evaluation of the expression A determines the object that
the name A designates.  In C, it can either do that *or* it can extract
the value currently stored in that object.

So if C was to behave the same way as BLISS:
     int a, b, c;
     b = 23;           // sets b to 23
     a = *b;           // sets a to that 23 in b
     c = *a + *b;      // sets c to 46
     a = b;             // attempts to set a to b's address (&b)
You would say that this is now symmetric, but C normal C wasn't?
I get you...
... not really! We'll just have to disagree. My comments are based on having implemented this stuff myriad times on multiple targets, but I must have obviously have been misunderstanding it all that time.
Opening a drawer A to put something in, is a totally different thing to opening the same drawer A to take something out; of course!