Re: Type conversion from Universal Integer

[dlc@ddsdx2.jhuapl.edu (Dave Collard x7468)]

In <1993Mar3.224845.18874@saifr00.cfsat.honeywell.com> murali@saifr00.cfsat.honeywell.com (R. Muralidhar) writes:
> -------------------------------------------------------------------------
>package P is
>  type A is range 1 .. 10;
>  type Array_Constrained_Type is array ( A range <> ) of Integer;
>end P;

>with P;
>procedure test is 

> Const : constant := 5;
> type Local_A is range 1 .. 10;

> type Local_Array_Constrained_Type is array ( Local_A range <> ) of Integer;

> subtype Array_type1 is P.Array_Constrained_Type(1 .. (const/2)); -- Line A
> subtype Array_type2 is P.Array_Constrained_Type(1 .. P."/"(const,2)); -- Line B
> subtype Array_type3 is Local_Array_Constrained_Type(1 .. (const/2)); -- Line C

>begin
>  null;
>end test;
> -------------------------------------------------------------------------

> detect an error on DEC Ada compiler, in the line marked "Line A", saying:

>%ADAC-E-RESTYPINCON, (1) Result type of expression is inconsistent with its  
>        context, which requires integer type A in P at line 2 [LRM 8.7] 

>But the same piece of code compiled fine under Verdix Ada Compiler on Sun.
no comment.

>Line B compiled fine in both compilers, so did Line C.

>Am I dealing here with some interpretation of a language feature that is
>implementation dependent? Or is it that one or the other compiler is wrong?


>Also, LRM 4.6(15) says that "An implicit conversion of an operand of
>universal integer to another integer type, ..., can only be applied if the
>operand is either a numeric literal, a named number, or an attribute;"

>I take it that the compiler tries to implicitly convert to the integer type A,
>the upper and lower bounds of the specified ranges in all three lines, 
>Line A, Line B, and Line C. Since (const/2) is an expression and is not a
>numeric literal, not a named number, and not an attribute, the compiler(s)
>should have detected errors in all three lines.

Ah, but Const IS a named number and 2 is a numeric literal, so,
  In line B, Const and 2 are converted to type P.A because the only P."/" available
  that matches the required return type (P.A) is the inherited division operator
  for type P.A.

  In line C the same thing is true except replace P.A with Local_A.

  Now Line A.  The expression (const/2) MUST evaluate to type P.A.  The only 
  division operator available that returns P.A is the one inherited in package
  P when the type A was derived.  That operation is not visible (as you did not
  use P).  Therefore, no division operator is visible which returns type P.A.
  The DEC compiler is correct (as usual).


--Thor
collard@capsrv.jhuapl.edu
dlc@ddsdx2.jhuapl.edu