Re: 64-bit integers in Ada

[dewar@gnat.com (Robert Dewar)]

"Marin David Condic" 

> so having the requirement is not a
> bad thing. 

Here is why I think it *is* a bad requirement.

No implementation would possibly make Integer less than
16 bits. None ever has, and none ever would. Remember that
the only really critical role of integer is as an index
in the standard type String (it was a mistake to have string tied in
this way, but it's too late to fix this)

No one would make integer 8 bits and have strings limited
to 127 characters. 

If you are worried about implementors making deliberately
useless compilers, that's a silly worry, since there are
lots of ways of doing that (e.g. declaring that any
expression with more than one operator exceeds the capacity
of the compiler).

So why is the requirement harmful? Because it implies that
it is reasonable to limit integers to 16 bits, but in fact
any implementation on a modern architecture that chose 16 bits for
integer would be badly broken.

As for implementations for 8-bit micros, I would still make
Integer 32 bits on such a target. A choice of 16-bit integer (as for
example Alsys did on early on) would cause
giant problems in porting code. On the other hand, a choice
of 32-bit integers would make strings take a bit more room. I would
still choose 32-bits.

Anyway, I see no reason for the standard to essentially encourage
inappropriate choices for integer types by adding a requirement that
has no practical significance whatever.

This is an old old discussion. As is so often the case on
CLA, newcomers like to repeat old discussions :-)

This particular one can probably be tracked down from the
design discussions for Ada 9X.