Re: Interfaces.Shift_Left

["Randy Brukardt" <randy@rrsoftware.com>]

"awdorrin" <awdorrin@gmail.com> wrote in message 
news:a76daa61-49f7-4235-af65-11973a012f35@v29g2000yqv.googlegroups.com...
>I understand what you are saying and I do agree in theory.
>
> The situation is that bit shifting is being used to retrieve data of
> various bit lengths and positions from compound records.
>
> For instance, retrieving a 6-bit signed value from a 32-bit field.

Right. This definitely should be done using record representation clauses if 
there is a choice. But of course if the code already exists, that might be 
too much.

> For the purposes of obtaining those 6 bits - sign is irrelevant, but
> that 6 bit value is then sent back to a calling process as an 'Int32'
> so I need the sign then.

Right. A record representation clause would do this correctly with no 
(visible) shifting, and it would be far less prone to errors. To take a 
quick example from my solitare solvers:

    Max_Score : constant := 1000;
    type Suits is (Diamonds, Hearts, Spades, Clubs);
    subtype Pip_Value is Natural range 1 .. 13; -- 1 = Ace, 13 = King. (I 
have names for these not shown here.)
    subtype Score_Value is Integer range -Max_Score..Max_Score;

    type Card is record
         Suit : Suits;
         Pip  : Pip_Value;
         Score : Score_Value;
    end record;
    for Card use record
         Suit at 0 range 14..15;
         Pip at 0 range 10..13;
         Score at 0 range 0..9;
    end record;
    for Card'Size use 16;

    Great_Card : constant Card := (Suit => Spades, Pip => 1, Score => 800);

Now, a reference to Great_Card.Score will give you a signed result, and the 
compiler will select the best set of shifts and masks for your target 
machine (not to mention combining them when possible). Much less 
complication, much easier to read, much less likely to make a mistake.

> Given more time and funding, I would replace this logic with something
> that makes more sense, but a quick Unchecked_Conversion saves
> rewriting 15,000+ lines of code. :)

I certainly understand, but personally I would guess that replacing the 
explicit shifting and masking with a record type would probably take me 
about the same time as writing all of the Unchecked_Conversion instances you 
would need. And there will be a lot less chance of error. YMMV, of course.

BTW, if there are really 15000 lines that would get changed by this, there 
is a really bad lack of encapsulation with this code. The interfaces between 
Ada and other languages/hardware/OSes should always be made as narrow as 
possible, and always should go through a well-encapulated interface (so it 
is easy to change one side without distrubing the other). But I realize that 
you probably know this.

                                                Randy.