Version 1.8 of ais/ai-00199.txt

Unformatted version of ais/ai-00199.txt version 1.8
Other versions for file ais/ai-00199.txt

!standard 10.01.05 (07)          00-03-07 AI95-00199/06
!class binding interpretation 98-03-27
!status Corrigendum 2000 99-07-27
!status WG9 approved 99-06-12
!status ARG approved (with editorial changes) 8-0-2 99-03-25
!status work item 98-04-02
!status received 98-03-27
!reference AI95-00041
!priority High
!difficulty Hard
!qualifier Clarification
!subject Pragma Convention for a generic unit applies to its instances
!summary
The following Implementation Advice is added:
Program unit pragmas that are not library-unit pragmas, when supported for a generic unit, should apply to all instances of the generic for which there is not an overriding pragma applied directly to the instance.
This Implementation Advice answers the question left open by AI-00041.
!question
Does pragma convention for a generic unit apply to instances? (Yes, if supported.)
!recommendation
There are four language-defined program unit pragmas which are not library-unit pragmas:
- pragma Inline
- pragma Convention
- pragma Import
- pragma Export
AI-00041 addressed the question of whether program unit pragmas applied to a generic, should also apply to its instances. It concluded they should not, in general, with pragma Inline as an exception, and with the claim that pragmas Convention, Import, and Export (the interfacing pragmas) do not in any case apply to generics.
However, there is nothing precluding implementations from supporting the interfacing pragmas for generic units. The natural interpretation for this is that the pragmas apply to all instances of the generic unit.
In general, AI-00041's conclusions that library unit pragmas on generics should not apply to instances makes sense, because there is no requirement that the instances be library units at all. However, for program unit pragmas that are not library unit pragmas, the most intuitive interpretation is that when applied to generic program units, they are "inherited" by the instances of the generic. For each of the four language-defined non-library-unit program unit pragmas, this rule makes sense, and it seems reasonable to assume that it would make sense for other similar pragmas. Of course, an implementation could always define a new "program-unit-ish" pragma for which it did not make sense, but implementations are allowed to define whatever semantics they choose for implementation-defined pragmas (subject to the usual recommendations about "good taste" in pragmas).
Although a program unit pragma on a generic should generally be "inherited" by its instances, it might be overridden by a pragma applied directly to the instance. This is analogous to the rule for inheriting representation items by a derived type from its parent type. The inherited specification may be overridden by a direct specification on the derived type itself.
!wording
(See summary.)
!discussion
AI-00041 includes a thorough analysis of all program-unit pragmas applicable to generic units other than the interfacing pragmas, and concludes that with the exception of pragma Inline, instances should not inherit pragmas from generic units. However, if the program-unit pragmas are instead separated into two groups, those which are library unit pragmas, and all others, it becomes more natural to say that only library unit pragmas are not "inherited" by instances (since of course the instances might not themselves be library units), whereas all other program unit pragmas are "inherited" by instances.
The contention in AI-00041 that the interfacing pragmas simply don't apply to generics is not true in some implementations. For those implementations that do support interfacing pragmas on generics, it seems that the natural interpretation is for the pragmas to be inherited by all instances.
Even though we propose that non-library unit program unit pragmas should be inherited by instances, we still want to allow overriding of such a pragma with one applied directly to the instance. Hence, even if a convention is specified on a generic, a pragma on a particular instance may override that convention.
!corrigendum 10.01.05(7)
Insert after the paragraph:
Certain program unit pragmas are defined to be library unit pragmas. The name, if any, in a library unit pragma shall denote the declaration of a library unit.
the new paragraph:
Static Semantics
A library unit pragma that applies to a generic unit does not apply to its instances. Any other program unit pragma that applies to a generic unit applies to an instance of the generic unless the instance has an overriding pragma.
!ACATS test
This ruling is not testable, because it applies only to implementations which choose to support Import/Export/Convention on generic units. None of these are required by the language.
!appendix

!section 13.9(3)
!subject does pragma convention for a generic unit apply to instances?
!reference AARM-13.9(3a), 13.11.2(3a)
!from Jesper Jørgensen
!reference 1998-15798.a Jesper Joergensen  1998-1-29>>
!discussion

The above mentioned paragraphs seem to imply that convention specified for a
generic unit is "inherited" to all its instances. Such a rule sounds
reasonable, but where is the proof in the reference manual?

The same rule could apply for pragma export and perhaps also import. Is that
the case?

The closest I could get to an answer to this question is AI-00041 which
unfortunately directly contradicts the above mentioned paragraphs by stating
that pragma convention, export and import can't be applied to a generic unit. I
think that AI-00041 is wrong on this!

-- Jesper

+---------------------------------------------------------------------+
|                                                                     |
|           \_\_\_\_   \_\_\_\_    \_\_\_\_       \_                  |
|            \_     \_  \_     \_  \_              \_                 |
|             \_      \_ \_      \_ \_       \_\_\_ \_                |
|              \_     \_  \_     \_  \_              \_               |
|               \_\_\_\_   \_\_\_\_    \_\_\_\_       \_              |
|                                                                     |
|  Jesper Jørgensen                                                   |
|  DDC-I A/S                            Phone:       +45 45 87 11 44  |
|  Gl. Lundtoftevej 1 B                 Fax:         +45 45 87 22 17  |
|  DK-2800 Lyngby, Denmark              Email:       jj@ddci.dk       |
+---------------------------------------------------------------------+

****************************************************************

!section 13.9(3)
!subject does pragma convention for a generic unit apply to instances?
!reference AARM-13.9(3a), 13.11.2(3a)
!reference 1998-15798.a Jesper Jørgensen
!from Tucker Taft 98-01-29
!reference 1998-15799.a Tucker Taft 1998-1-29>>
!discussion

: The above mentioned paragraphs seem to imply that convention specified for a
: generic unit is "inherited" to all its instances. Such a rule sounds
: reasonable, but where is the proof in the reference manual?

: The same rule could apply for pragma export and perhaps also import. Is that
: the case?

Yes, I believe that pragmas Convention, Import, and Export
should all be inherited by the instances of a generic, just
like pragma Inline.

: The closest I could get to an answer to this question is AI-00041 which
: unfortunately directly contradicts the above mentioned paragraphs by stating
: that pragma convention, export and import can't be applied to a generic unit. I
: think that AI-00041 is wrong on this!

I agree with you.  Pragmas convention, export, and import can be
applied to a generic.  For example, it makes perfect sense to
apply pragma Import(Intrinsic, ...) to the generic function
Ada.Unchecked_Conversion.  It is unlikely that there will be
a body for this generic written in Ada, but instead its "body"
will be built into the compiler.  Similarly, applying a pragma
convention to a generic subprogram clearly indicates that instances
should use the specified calling convention.  Finally, applying
pragma Export to a generic implies that all instances should be
externally callable, perhaps with a given specified External_Name.
Specifying a link_name would be tricky, given that having multiple
instances with the same Link_Name would cause ambiguity at
link time.  However, External_Names could all be the same presuming
the language to which the instances are being exported supports
overloading (e.g. Java or C++).

In general, I believe AI-00041 should only apply to library
unit pragmas.  For program unit pragmas that are not library
unit pragmas (i.e. pragmas Inline, Convention, Export, and Import)
it makes perfect sense that all instances inherit the pragma.
For library unit pragmas, it does not make as much sense for the
instances to inherit the pragmas, mostly because there is no
requirement that the instances end up being library units at all.

: -- Jesper

: |  Jesper Jørgensen                                                   |
: |  DDC-I A/S                            Phone:       +45 45 87 11 44  |
: |  Gl. Lundtoftevej 1 B                 Fax:         +45 45 87 22 17  |
: |  DK-2800 Lyngby, Denmark            Email:       jj@ddci.dk       |

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

****************************************************************

Questions? Ask the ACAA Technical Agent