Re: 64-bit integers in Ada

[Richard Riehle <richard@adaworks.com>]

Robert Dewar wrote:

> As for implementations for 8-bit micros, I would still make
> Integer 32 bits on such a target.

I assume you are talking about Standard.Integer.   If so, this
would not correspond to the way software is so frequently
written for these machines.   In particular, for I-8051
platforms, it would introduce a potential inefficiency and
force the programmer to explicitly declare a shorter
integer (absent the availability of Standard.Short_Integer).

Since we often counsel designers to specify their own numeric
types anyway, this is probably not a hardship, but it could
be troublesome for an experienced I-8051 programmer who
expects 16 bit integers.   Consider, for example, that simply
pushing a 16 bit entity on the stack requires storing two
eight-bit stack entries.   To store a 32-bit integer would
take four stack entries.   The corresponding inefficiency
would be intolerable for most I-8051 applications.

One reason I like Ada is because we can define our own
numeric types.  Though there are few machines still extant
that use storage multiples of other than eight-bits,  they
do still exist.   I think the compiler for the Unisys 11xx
series has a word size of 36 bits.  Randy can correct me
on that if I am wrong.

> 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.

I completely agree with you on this point.  The designer should make
the decision based on the architecture of the targeted platform and
the application requirements.  The language should be, as Ada is,
flexible enough to give the designer this level of support.

Don Reifer recently told me that one reason Ada was becoming
irrelevant, and his reason for recommending against its use for
new projects, was that it is not sufficiently flexible to support
the new kinds of architectures in the pipeline.   Though I disagree
with him on this assessment,  forcing the language to correspond
to a single word-size architecture (read 32 bits) would be
play into his flawed view of Ada's value for new software.

Richard Riehle