Re: OS Bindings (was: Where is the elusive jump command?)

["Tarjei T. Jensen" <tarjei.jensen@kvaerner.com>]

Robert Dewar wrote
>Actually I have seen quite a bit of C code that uses the
>type size_t for addressing computations (a not unreasonable
>choice) where wrap around semantics is just what you want.

I'm quite certain that the only situation which would require modular semantics
for a size_t would be if it were used in a hash function or encryption
function.

[This may not apply for someone who is writing a compiler or a loader.] There
are two big probems with wraparound for size_t. One is that there may be a lot
of strange stuff high up (perhaps above the stack). Not to mention the stack
and the other is that  around zero there may be problems as well. Both these
things make wraparound semantics for size_t dangerous.

I know the offsetof function which uses offsets from address zero to compute
offsets in C. But that use does not require modular semantics for size_t. In
the book that I have available offsetof is a macro defined as "#define
offsetof(type, memb) ((size_t) &((type *)0)->memb)"

There is no doubt that there is a lot of work done manipulating size_t, but I
don't remember a seeing a single use which involved modular semantics. There
might be the occational &, but that's it.

I'm not convinced that these things would be something that an Ada programmer
would find neccessary to do. In C these tricks may be neccessary, but in Ada
much less so. That is after all why we have all the various attributes.

>Address computations using size_t are one of many examples.

If you are programming in C, you may have need to abuse the type, but in Ada???
Most of the information we would use size_t for are available as attributes. We
might need to convert from bits to bytes, but that's it.


Greetings,