type casting tagged types in the wrong direction

type casting tagged types in the wrong direction

[James A. Squire]

I have a question:

Say I have something like:

type A is tagged
  record
    X : ABC;
    Y : DEF;
  end record;

type B is new A with
  record
    W : GHI;
  end record;

type C is new B with
  record
    Z : JKL;
  end record;


OK.  Now, let's say that I forgot which type extends off of which, and I
write a statement like this:

  Jim  : C;
  Jane : B;
  Save : JKL;

begin
  ...
  Jim := C (Jane);
  Save := Jim.Z;
  ...
end;

GNAT 3.03 compiles this statement.  Is that really right?  Is Jim.Z
defined?
According to the LRM 4.6, the above is called a "view conversion".  This
raises the question, how do you take a type C view of a type B entity
when type C looks for additional information?

Should a validated Ada95 compiler flag this usage?  I realize that GNAT
is not validated.

I would appreciate any expert or otherwise opinions that any of you have
to offer.
Thank you.
--
James Squire
MDA Avionics Tools & Processes
ja_squire@csehp3.mdc.com
"one of these days I'm going to better myself by going to Knight school"

Re: type casting tagged types in the wrong direction

[Norman H. Cohen]

In article <3159B860.28A6@csehp3.mdc.com>, "James A. Squire"
<m193884@CSEHP3.MDC.COM> writes: 

|> Say I have something like: 
|>
|> type A is tagged
|>   record
|>     X : ABC;
|>     Y : DEF;
|>   end record;
|>
|> type B is new A with
|>   record
|>     W : GHI;
|>   end record;
|>
|> type C is new B with
|>   record
|>     Z : JKL;
|>   end record;
|>
|>
|> OK.  Now, let's say that I forgot which type extends off of which, and I
|> write a statement like this: 
|>
|>   Jim  : C;
|>   Jane : B;
|>   Save : JKL;
|>
|> begin
|>   ...
|>   Jim := C (Jane);
|>   Save := Jim.Z;
|>   ...
|> end;
|>
|> GNAT 3.03 compiles this statement.  Is that really right?  Is Jim.Z
|> defined?

The expression Jim.Z is perfectly legal, but the type conversion C(Jane)
is not.  This should be flagged as a compile-time error, because it does
not satisfy the conditions in either 4.6(22) or 4.6(23).

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

Re: type casting tagged types in the wrong direction

[Tucker Taft]

James A. Squire (m193884@CSEHP3.MDC.COM) wrote:
: I have a question:

: Say I have something like:

: type A is tagged
:   record
:     X : ABC;
:     Y : DEF;
:   end record;

: type B is new A with
:   record
:     W : GHI;
:   end record;

: type C is new B with
:   record
:     Z : JKL;
:   end record;


: OK.  Now, let's say that I forgot which type extends off of which, and I
: write a statement like this:

:   Jim  : C;
:   Jane : B;
:   Save : JKL;

: begin
:   ...
:   Jim := C (Jane);

This is illegal, by RM95 4.6(21-23).

:   Save := Jim.Z;
:   ...
: end;

: GNAT 3.03 compiles this statement.  Is that really right?  

No.  GNAT should have complained at compile time about the conversion
from B to C.  You may convert from B'Class to C (and then a run-time
check is performed), or you may convert from C to B, but a direct
conversion from B to C is illegal.

: ... Is Jim.Z defined?

Jim.Z is "defined," but the conversion on the previous line
is illegal, so who knows what code GNAT is generating for the
assignment to Jim.

: According to the LRM 4.6, the above is called a "view conversion".  This
: raises the question, how do you take a type C view of a type B entity
: when type C looks for additional information?

You can't.

: Should a validated Ada95 compiler flag this usage?  I realize that GNAT
: is not validated.

GNAT is validated, but validation doesn't guarantee bug-free
(nor does anything else I know of ;-).

This looks like a bug in GNAT, pure and simple.  (It also *suggests*
that another ACVC test might be in order ;-).

: I would appreciate any expert or otherwise opinions that any of you have
: to offer.
: Thank you.
: --
: James Squire
: MDA Avionics Tools & Processes
: ja_squire@csehp3.mdc.com
: "one of these days I'm going to better myself by going to Knight school"

-Tucker Taft   stt@inmet.com   http://www.inmet.com/~stt/
Intermetrics, Inc.  Cambridge, MA  USA

Re: type casting tagged types in the wrong direction

[Robert Dewar]

Norman said:

"The expression Jim.Z is perfectly legal, but the type conversion C(Jane)
is not.  This should be flagged as a compile-time error, because it does
not satisfy the conditions in either 4.6(22) or 4.6(23)."

GNAT certainly agrees:

    28.   Jim := C (Jane);
                    |
        >>> downward conversion of tagged objects not allowed

:-)

Re: type casting tagged types in the wrong direction

[Robert Dewar]

Jon said

": Should a validated Ada95 compiler flag this usage?  I realize that GNAT
: is not validated."

You realize wrong! GNAT was the first general purpose Ada 95 compiler
to be validated. We validated on the floor at Tri-Ada 96, and are now
the proud owners of ACVC 2.0 validation certificates numbers 2, 3 and
4. These validations were for SGI machines, but we expect many othr
GNAT validations in the future.

Of course validation does not ensure 100% compliance, so it is by no
means amazing to find a bug, but in fact this particular bug is
certainly fixed now (I don't know when exactly it was fixed), and
we now get a nice error message.

Re: type casting tagged types in the wrong

[Scott Moody]

I run this same program with GNAT 3.03 on solaris
and it reports the error correctly:

tmp.adb:24:14: downward conversion of tagged objects not allowed
gnatmake: *** compilation failed.


----source:
procedure tmp is

 type A is tagged
   record
     X : integer;
     Y : integer;
   end record;

 type B is new A with
   record
     W : integer;
   end record;

 type C is new B with
   record
     Z : integer;
   end record;

   Jim  : C;
   Jane : B;
   Save : integer;

 begin
   Jim := C (Jane);
   Save := Jim.Z;
 end;

Re: type casting tagged types in the wrong direction

[Fergus Henderson]

dewar@cs.nyu.edu (Robert Dewar) writes:

>You realize wrong! GNAT was the first general purpose Ada 95 compiler
>to be validated. We validated on the floor at Tri-Ada 96, and are now
>the proud owners of ACVC 2.0 validation certificates numbers 2, 3 and
>4.

So who got validation certificate number 1?

--
Fergus Henderson             	WWW: http://www.cs.mu.oz.au/~fjh
fjh@cs.mu.oz.au              	PGP: finger fjh@128.250.37.3

Re: type casting tagged types in the wrong direction

[Robert Dewar]

"
So who got validation certificate number 1?"

Intermetrics, for the Patriot 2 compiler. But I don't think that
qualifies as a generl purpose compiler -- not too many people have
a Patriot 2 nosecone sitting on their desks.

Actually several validations happened pretty close. Intermetrics was
a couple of weeks before Tri-Ada, GNAT validated at Tri-Ada, and
Thompson validated a couple of weeks after Tri-Ada (the latter
compiler of course also quaifies as general purpose!)

Re: type casting tagged types in the wrong

[James A. Squire]

Scott Moody <scott@PLATO.DS.BOEING.COM> wrote:

> I run this same program with GNAT 3.03 on solaris
> and it reports the error correctly:
>
> tmp.adb:24:14: downward conversion of tagged objects not allowed
> gnatmake: *** compilation failed.
>
> ----source:
[source snipped]

I just ran it myself against the same compiler on the same platform and
to my chagrin I got the same error message.

I had figured that the bug would be consistant.  The place where I found
it
was in the Alert system that is partially coded in the Rationale.  I
added code for the other subunits besides Handle, and then I switched
the overloads of Handle so that the one for Medium Alerts called the one
for High Alerts instead of the one for Alerts.  I made sure the subunit
for Set_Alarm actually tried to read the extra field.  In this case
there was no error on the line:

Handle (HA => High_Alert(MA));

I will send this off to report@gnat.com.
--
James Squire
MDA Avionics Tools & Processes
ja_squire@csehp3.mdc.com
"one of these days I'm going to better myself by going to Knight school"