Re: Ada.Strings.Bounded

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Eric Hughes <eric.eh9@gmail.com> writes:

> On Apr 21, 6:49 pm, Adam Beneschan <a...@irvine.com> wrote:
>> See 4.9(33).
>
> Oh.  OK.  For those insufficiently motivated to look at this section,
> it says that static expressions are evaluated exactly, without
> performing overflow checks.

Right.

>...To me, that word "exactly" means that
> static expressions are evaluated as universal_integer, since that's
> the only way to get them defined exactly.

No, that does not follow.  It says they are evaluated exactly,
which means the compiler must get the right answer, according
to the normal rules of integer math.  That has nothing to do
with univ_int.

> Previously, Bob Duff had said:
>> An integer literal has type universal_integer, as you said, but
>> universal_integer has no "+" operator.  There is a "+" for root_integer,
>> and also for user-defined integer types.  Universal_integers can be
>> implicitly converted to various integer types.
>
> Something's got to give here.  I see the following possibilities:
> 1) universal_integer actually does have a "+" operator.

It does not.  It doesn't need them, since univ_int can be implicitly
converted to any other integer type.  And if univ_int had operators,
lots of useful expressions would be ambiguous, and therefore illegal!

>...It would only
> be available at compile time, since there's no way to declare a
> variable of type universal_integer.

However, there are some fairly obscure ways to write nonstatic
expressions of type universal_integer, and pass those to
the operators of type root_integer, at run time.  These will
get overflows -- Constraint_Error if the value doesn't fit in
the base range of root_int (the 64-bit range, for GNAT).

> 2) The addition chosen is the context-dependent one, as for dynamic
> expressions, but when overflow happens, the result is magically
> converted to universal_integer.

No.

> 3) The addition of the ordinary type is tried with the base type.  If
> it overflows, a bigger type is tried, and so on up to
> universal_integer, which will always succeed.

No.

> 4) The evaluation happens purely mathematically, without regard for
> the Ada type system.

Yes.  That is, the "+" operator of all types behaves that way in static
expressions.

> 5) There are different versions of the type and its addition operation
> for static and run-time use.  The static ones have arbitrarily large
> capacity and exact arithmetic.

Sort of.  I wouldn't call it "different versions of the type", though.
The operators behave differently in static expressions than at run
time.  There's nothing special about the root_int ops in this regard
(and there are no univ_int ops).

> I'm sure my imagination is not large enough to guess at all the
> possibilities.  What's going on here, really?

I hope my comments above answer that question!  ;-)

- Bob