Fixed point operator visibility question

Fixed point operator visibility question

[Michael Cook]

I have a question about fixed point operations, based on the example
at the end of this article.

The example compiles using compilers from vendors B, C, and D.  The
example does not compile using a compiler from vendor A, unless the
'use' clause is in effect.

My viewpoint is that fixed point division is defined by package
STANDARD, see Ada RM, section 4.5.5, para 9-11.  And so the division
should be visible without the 'use' clause.

Vendor A's claim is that the example deals with visibility of
operations of derived types.  The argument is that Fixed_Type is
a derived type of an anonymous predefined fixed point type (RM
3.5.9 para 9).

The derived type introduces a derived "/" operator, that hides the
predefined "/" operator in the scope of the declaration of Fixed_Type
(RM 3.4 para 5).

The 'use' clause is needed to access the derived operation in a using
context, per visibility rules in RM 8.3.

The argument continues that it doesn't matter that Fixed_Type is a
fixed point type.  The same thing would happen if a derived type of,
say, Integer was used.

Which viewpoint is correct, or are both defendable?  Is there an ACVC
test that checks for this, or an AI that would help?  Is vendor A
correct and the others lax in visibility checking?

I'd suggest some test like this for the ACVC suite if a definite
position can be argued.

For now, I'll just add the 'use' clause for expediency.

Thanks for ideas.

Michael Cook
MLC@IBERIA.CCA.ROCKWELL.COM
These are not the opinions of my employer.


package Fixed_Type_Example is

   Fixed_Type_Delta : constant := 1.0 / (2.0 ** 27);

   type Fixed_Type is delta Fixed_Type_Delta range -16.0 .. 16.0;

end Fixed_Type_Example;

-------------------------

with Fixed_Type_Example;

package Example is

   procedure Initialize;

end Example;

-------------------------

package body Example is

   -- Should 'use' clause be necessary?

   -- Adding the 'use' clause removes the compilation problem,
   -- but violates our coding standard.
 
   -- use Fixed_Type_Example;          -- needed by vendor A

   type Value_Type is range -2**15 .. 2**15 - 1;


   procedure Initialize is

      H   : Fixed_Type_Example.Fixed_Type;
      PH  : Fixed_Type_Example.Fixed_Type;
   
      PCV : Value_Type;

   begin

      H   := 6.236;
      PH  := 0.0129;

      PCV := Value_Type (H / PH);

   end Initialize;


end Example;

Re: Fixed point operator visibility question

[Robert I. Eachus]

In article <00985E28.98D9FB40.9907@iberia.cca.rockwell.com> mlc@iberia.cca.rockwell.com (Michael Cook) writes:

 > My viewpoint is that fixed point division is defined by package
 > STANDARD, see Ada RM, section 4.5.5, para 9-11.  And so the division
 > should be visible without the 'use' clause.

 > Vendor A's claim is that the example deals with visibility of
 > operations of derived types.  The argument is that Fixed_Type is
 > a derived type of an anonymous predefined fixed point type (RM
 > 3.5.9 para 9).

    You are correct.  And that is the most bogus version of "its not a
bug it is a feature" I have ever seen.

    There is no fixed by fixed division operation defined for
Fixed_Type or its parent, so whether or not it is a derived type is
irrelevant.  In any case the division operation for _universal_fixed_
that applies here is defined in STANDARD, and will be visible without
the use clause.

    Give the vendor fifty lashes with a wet noodle, served with heaping
amounts of supercilious scorn. ;-)

--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...

Re: Fixed point operator visibility question

[Norman H. Cohen]

In article <00985E28.98D9FB40.9907@iberia.cca.rockwell.com>,
mlc@iberia.cca.rockwell.com (Michael Cook) writes: 

|> My viewpoint is that fixed point division is defined by package
|> STANDARD, see Ada RM, section 4.5.5, para 9-11.  And so the division
|> should be visible without the 'use' clause.

You are quite right.  See also the last two declarations in Annex C,
paragraph 11.

|> Vendor A's claim is that the example deals with visibility of
|> operations of derived types.  The argument is that Fixed_Type is
|> a derived type of an anonymous predefined fixed point type (RM
|> 3.5.9 para 9).
|>
|> The derived type introduces a derived "/" operator, that hides the
|> predefined "/" operator in the scope of the declaration of Fixed_Type
|> (RM 3.4 para 5).

Vendor A is wrong.  The "/" operator in question is not an operation of
the parent fixed-point type.  Rather, it is a "magic" operation that
takes operands of ANY fixed-point type and produces a result of type
universal_fixed.  Thus it is not inherited.

|> package Fixed_Type_Example is
|>
|>    Fixed_Type_Delta : constant := 1.0 / (2.0 ** 27);
|>
|>    type Fixed_Type is delta Fixed_Type_Delta range -16.0 .. 16.0;
|>
|> end Fixed_Type_Example;
|>
|> -------------------------
|>
|> with Fixed_Type_Example;
...
|>    type Value_Type is range -2**15 .. 2**15 - 1;
...
|>       H   : Fixed_Type_Example.Fixed_Type;
|>       PH  : Fixed_Type_Example.Fixed_Type;
|>
|>       PCV : Value_Type;
...
|>       PCV := Value_Type (H / PH);

--
Norman H. Cohen    ncohen@watson.ibm.com