Array mappings

[mfeldman@seas.gwu.edu (Michael Feldman)]

In article <3c4g1u$uh6@watnews1.watson.ibm.com>,
Norman H. Cohen <ncohen@watson.ibm.com> wrote:

>The way to use ISUB when passing PL/I arrays to Fortran (or, as it was
>called back then, FORTRAN) is to declare an ordinary array that is filled
>in column-major (i.e., as Fortran expects it).  If, inisde the PL/I
>program, you want to view the data as arranged in row-major order, then
>declare an ISUB that creates a virtual transposed copy of the array.
                                ^^^^^^^
OK, this makes it clear.

>It is the ordinary array that is passed to Fortran, so it is unnecessary
>to create a transposed copy of the array.  (If the array is to be passed
>from one PL/I procedure to another, the ordinary array can be passed and
>the ISUB declaration repeated in the called procedure.)

Aha. This is nice stuff. Perhaps I moved to other things before this
was implemented (or at least well-known) in PL/I.

That this was implemented in PL/I in the mid-70's, or even earlier,
a fact presumably known to the Ada 83 designers, makes me even more 
curious why a similar facility was not provided in Ada 83. pragma Interface 
handles the subprogram interface but there is no corresponding way
to handle the data structure interface.

This is odd - Ada 93 deliberately leaves array mappings (like all
representations) unspecified, so (presumably) as to allow flexibility
in the implementations. Was a pragma equivalent to Convention thought
to be "feature overkill"? 

Finally, even if it was not predefined, such an implementation-defined
pragma would have been legal. Given that there were quite a number of
implementation-defined pragmas in Ada 83 - including such things as
Export, to allow callbacks - why did not this one turn up. I am still
waiting for an implementer to say "we looked at that market carefully
and concluded it was not worth the trouble."  Till then, I stick to
my conjecture that nobody really looked at all that Fortran and
thought about how to sell into that crowd.

It's water over the dam, of course, because of Interfaces.Fortran in
Ada 95. But will we see timely implementations of it (other than GNAT,
which supports it in version 2)?

Mike Feldman