Re: How do I write directly to a memory address?

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 08.02.11 11:43, Ludovic Brenta wrote:
> Georg Bauhaus wrote on comp.lang.ada:
>> On 2/8/11 11:16 AM, Ludovic Brenta wrote:
>>>> Strict contracts in subprogram profiles. Ha!
>>
>>>> void foo2(int jump)
>>>>     /* make sure jump % 2 == 0! */
>>>> {
>>>>      ...
>>>> }

> procedure Foo2 (Jump : in Natural) is
> begin
>    if Jump <= Natural'Last / 2 then
>       Baz (2 * Jump);
>    else
>       declare
>          Half_Jump : constant Natural := Jump / 2;
>          Remainder : constant Natural := Jump mod 2;
>       begin
>          Baz (2 * Half_Hump);
>          Baz (2 * Half_Jump);
>          if Remainder /= 0 then
>             Baz (2 * Remainder);
>          end if;
>       end;
>    end if;
> end Foo2;
> 
> And that's assuming Long_Long_Integer is not wide enough for the
> calculations.


There is lots of assuming here.  The original "contract" read

void foo2(int jump)
     /* make sure jump % 2 == 0! */
{
   ...
}

(And int includes negative values.)  The idea could have
been that the least significant bit is not set.  Or the idea
could have been different.  The point is, neither language
provides the means of expressing the idea using types.

Not yet.

The knee jerk reaction of the Ada programmer is to invent
a different problem and its solution and show off.

It's counterproductive.

So, more specifically, define an integer subtype T whose values
do not include the values of the static constants A, B, and C,
assuming that each of A, B, and C will be members of a
proper subrange of T'Range.  Make sure that membership in T
can be checked at compile time.

Do the same for run-time values A, B, and C.

What I'd like to point out is that we need a better utility
function.  A function that properly measures program quality.
I imagine that type checking quality vs the type system's
flexibility of the respective languages form one variable
of the utility function.