Re: Is there ANY chance we can fix the bitwise operator precedence rules?

[bearophile]

Jonathan M Davis:

>Well, I would pount out that you mentioning it more or less reopens the 
>discussion,<

You are right, but probably Walter will not sue me for reopening an old thread 
;-)


In the things you are saying you seem to ignore the "goto" I have written two 
times in my answers :-)


>An extension of that is if you have two cases which are almost identical but 
>where one of them needs to do something first before the code that is common 
>between both cases.<

You can write this C-style switch:

switch (x) {
    case 0: foo();
    case 1: bar();
}

As this (this is D syntax that you can already use):

void main() {
    int x, y;
    switch (x) {
        case 0: y++; goto case 1;
        case 1: y++;
        default:
    }
}


> A more complicated example would be one where you're doing something like
> Duff's Device:
> 
> send(to, from, count)
> register short *to, *from;
> register count;
> {
>         register n=(count+7)/8;
>         switch(count%8){
>         case 0: do{     *to = *from++;
>         case 7:         *to = *from++;
>         case 6:         *to = *from++;
>         case 5:         *to = *from++;
>         case 4:         *to = *from++;
>         case 3:         *to = *from++;
>         case 2:         *to = *from++;
>         case 1:         *to = *from++;
>                 }while(--n>0);
>         }
> }


You can use gotos (this is a different function, it copies whole arrays, 'to' 
too is incremented):

import std.stdio: writeln;

void arrryCopy(short* to, short* from, int count) {
    foreach (_; 0 .. count / 8) {
        *to++ = *from++; *to++ = *from++;
        *to++ = *from++; *to++ = *from++;
        *to++ = *from++; *to++ = *from++;
        *to++ = *from++; *to++ = *from++;
    }

    final switch (count % 8) {
        case 7: *to++ = *from++; goto case 6;
        case 6: *to++ = *from++; goto case 5;
        case 5: *to++ = *from++; goto case 4;
        case 4: *to++ = *from++; goto case 3;
        case 3: *to++ = *from++; goto case 2;
        case 2: *to++ = *from++; goto case 1;
        case 1: *to++ = *from++; break;
        case 0: break;
    }
}

void main() {
    short[9] a1 = 1;
    short[a1.length] a2;
    writeln(a1, "   ", a2);

    arrryCopy(a2.ptr, a1.ptr, a1.length);
    writeln(a1, "   ", a2);
}


I have used the static switch to avoid the default case.
Using gotos like that is a bit less conventient than the C code, but I think it 
can be acceptable.

> switch(value)
> {
>     case 0:
>         do something...
>     case 1:
>         do something else...
>     case 2:
>         do a third thing...
>     case 3:
>         do yet more...
> }


You can translate it as:

switch(value)
{
    case 0:
        do something...
        goto case 1;
    case 1:
        do something else...
        goto case 2;
    case 2:
        do a third thing...
        goto case 3;
    case 3:
        do yet more...
        break;
    default:
        ...
}

Bye,
bearophile