Re: Universal float or not - who's right ?
- From: "Adam Beneschan" <adam@xxxxxxxxxx>
- Date: 8 Sep 2006 10:13:37 -0700
Gautier wrote:
Hullo - here is a nice case, with a trivial workaround given first, where 3
compiler differs. Question to the Ada RM exegetes: who is right ?
package FF is
type FFloat is new Float;
end;
with FF;
procedure Beauripple is
generic
type Num is digits <>;
x : Num;
package P is end;
c: constant:= 2.0**4;
package FPc is new P(FF.FFLoat,c);
-- Passes on compilers A,B,C - as expected
d: constant FF.FFLoat:= 2.0**4;
-- Fails on compiler A,B,C
-- "**" is not visible, an "use FF;" is missing
package FPe is new P(FF.FFLoat,2.0**4);
-- ** A,B,C differ:
-- Passes on C: (2.0**4) probably taken as universal float
-- Fails on compiler A,B: same reason as for constant d
begin
null;
end;
The declaration of "d" and of the instance FPe should both be rejected,
but understanding why requires understanding the difference between
universal_real and root_real, which is something that always confuses
the daylights out of me, so I hope I'm getting this right. All
floating-point literals are universal_real and can be used as an actual
for any subprogram parameter that is of any real type. However,
universal_reals don't have primitive subprograms, so there's no "**"
that returns a universal_real. Instead, there's a "**" that takes a
root_real and an Integer'Base parameter and returns a root_real. When
you say 2.0**4, and the "**" implicitly defined for FFloat is not
visible, then "**" can refer to the subprogram
function "**" (Left : root_real; Right : Integer'Base) return
root_real;
or to a "**" function defined for a predefined type like Float.
When you say
d: constant FF.FFloat := 2.0**4;
the expected type for the expression is FF.FFloat. This means that the
expression can have type FF.FFloat or it can be a universal_real, but
it can't be any other type, including root_real. So it's illegal. The
exact same logic applies to the instantiation---the expected type for
the generic actual parameter is Num, which is the same as FF.FFloat.
(So compiler C is wrong to accept it.)
Both of these will work, though:
d: constant FF.FFloat := c;
d: constant FF.FFloat := FF.FFloat (2.0**4); --type conversion,
not qualified expression!!
The first works because "c" is a named number and therefore has type
universal_real; in the second case, 2.0**4 will have type root_real
which can be converted to FF.FFloat. Similarly for the instantiation
(you've already demonstrated that using the named number works).
References: RM95 3.3.1(4), 3.3.2(3,5), 3.4.1(6-7), 4.5.6(9-10),
8.6(22,24,29), 12.4(4)
Hope this helps.
-- Adam
.
- References:
- Universal float or not - who's right ?
- From: Gautier
- Universal float or not - who's right ?
- Prev by Date: Re: Martian Rover Spirit's mulitasking software reset.
- Next by Date: Re: wxAda (pre-pre-pre-pre-release)
- Previous by thread: Universal float or not - who's right ?
- Next by thread: Re: Universal float or not - who's right ?
- Index(es):
Relevant Pages
|
