CVS difference for ais/ai-00117.txt

Differences between 1.11 and version 1.12
Log of other versions for file ais/ai-00117.txt

--- ais/ai-00117.txt	2000/07/13 04:31:27	1.11
+++ ais/ai-00117.txt	2000/07/15 02:29:56	1.12
@@ -11,11 +11,11 @@
 !priority High
 !difficulty Hard
 !qualifier Omission
-!subject Calling Conventions
+!subject Calling conventions
 
 !summary
 
-Unless specified otherwise in the RM, the default convention of any
+Unless specified otherwise in the standard, the default convention of any
 entity is Ada.
 
 An inherited or overriding subprogram of a type extension inherits the
@@ -30,56 +30,56 @@
 
 An explicitly declared dispatching operation shall not have convention
 Intrinsic. However, an implicitly declared dispatching "/=" operator with
-boolean result legally has convention Intrinsic.
+Boolean result legally has convention Intrinsic.
 
 !question
 
-6.3.1 defines the default convention of various entities (that is, the
+6.3.1(2-13) defines the default convention of various entities (that is, the
 convention in the absence of a convention-specifying pragma):
 
-  2   As explained in B.1, ``Interfacing Pragmas'', a convention can be
+  As explained in B.1, ``Interfacing Pragmas'', a convention can be
   specified for an entity.  For a callable entity or access-to-subprogram type,
   the convention is called the calling convention.  The following conventions
   are defined by the language:
 
-      3  The default calling convention for any subprogram not listed
-         below is Ada.  A pragma Convention, Import, or Export may be used
-         to override the default calling convention (see B.1).
+      The default calling convention for any subprogram not listed
+      below is Ada.  A pragma Convention, Import, or Export may be used
+      to override the default calling convention (see B.1).
 
-      4  The Intrinsic calling convention represents subprograms that are
-         ``built in'' to the compiler.  The default calling convention is
-         Intrinsic for the following:
+      The Intrinsic calling convention represents subprograms that are
+      ``built in'' to the compiler.  The default calling convention is
+      Intrinsic for the following:
 
-             5  an enumeration literal;
+         an enumeration literal;
 
-             6  a "/=" operator declared implicitly due to the declaration
-                of "=" (see 6.6);
+         a "/=" operator declared implicitly due to the declaration
+         of "=" (see 6.6);
 
-             7  any other implicitly declared subprogram unless it is a
-                dispatching operation of a tagged type;
+         any other implicitly declared subprogram unless it is a
+         dispatching operation of a tagged type;
 
-             8  an inherited subprogram of a generic formal tagged type
-                with unknown discriminants;
+         an inherited subprogram of a generic formal tagged type
+         with unknown discriminants;
 
-             9  an attribute that is a subprogram;
+         an attribute that is a subprogram;
 
-            10  a subprogram declared immediately within a protected_body.
+         a subprogram declared immediately within a protected_body.
 
-         11   The Access attribute is not allowed for Intrinsic
+         The Access attribute is not allowed for Intrinsic
          subprograms.
 
-     12  The default calling convention is protected for a protected
-         subprogram, and for an access-to-subprogram type with the
-         reserved word protected in its definition.
+     The default calling convention is protected for a protected
+     subprogram, and for an access-to-subprogram type with the
+     reserved word protected in its definition.
 
-     13  The default calling convention is entry for an entry.
+     The default calling convention is entry for an entry.
 
-- ----------------
+-----------------
 
 1. What is the default convention of an entity not covered by 6.3.1,
 such as a record type?  (Ada.)
 
-- ----------------
+-----------------
 
 2. Does an inherited or overriding subprogram have (by default) the same
 convention as the parent subprogram?  (Yes.)
@@ -98,7 +98,7 @@
 
 On the other hand, 3.4(18) says:
 
-       18   The profile of an inherited subprogram (including an
+       The profile of an inherited subprogram (including an
        inherited enumeration literal) is obtained from the profile of
        the corresponding (user-defined) primitive subprogram of the
        parent type, after systematic replacement of each subtype of its
@@ -112,7 +112,7 @@
 These paragraphs seem to imply that an inherited subprogram inherits the
 calling convention of its parent, as part of the inherited profile.
 
-- ----------------
+-----------------
 
 3. Is an implicitly declared dispatching "/=" operator legal?  (Yes.)
 
@@ -164,7 +164,7 @@
 convention of the type, for convenient interfacing to other OOP
 languages.  (See below for more discussion of this point.)
 
-- ----------------
+-----------------
 
 2. It is important that Ada allow clean interfaces to other programming
 languages.  In particular, it is important that Ada's tagged types can
@@ -176,7 +176,7 @@
 other language.  Presumably, all of the dispatching operations of this
 foreign type would be defined as imported, with the convention of
 that other language.  When defining the type extension in Ada, it
-would be very inconvenient if every overriding would have to have
+would be very inconvenient if every overriding needed
 a pragma Convention on it to match that of the inherited operation,
 as required by 3.9.2(10).
 
@@ -214,7 +214,6 @@
 of different, explicitly specified conventions or of explicitly
 specified conventions different from the convention of the type.
 
-- ----------------
 2.a. The "Breach of Privacy" Issue
 
 Presently, the convention of a primitive subprogram can be specified
@@ -237,7 +236,6 @@
 breach the private part, as subtype conformance of overriding with
 inherited subprograms includes checking for equality of the convention.
 
-- ----------------
 2.b. Deriving the convention of operations from the type
 
 Having dispatching operations with the convention of some
@@ -255,7 +253,7 @@
 Since current rules imply that the convention of a type needs to be
 specified for the full view of the type, such dependency creates yet
 another breach of privacy in the case of private tagged types. However,
-the breach already exists as explained in 2.a. and to then exploit it
+the breach already exists as explained in 2.a. and then to exploit it
 for more convenience to the user and a cleaner overall model seems
 justified.
 
@@ -263,7 +261,6 @@
 order to avoid the breach of privacy seems too much of an
 incompatibility for existing code.
 
-- ----------------
 2.c. The convention of a partial view
 
 As mentioned previously, the current rules of the standard require that
@@ -273,7 +270,7 @@
 same entity. However, while this is obvious, it is also not mentioned in the
 standard. A statement to this effect needs to be added to 13.1.
 
-- ----------------
+-----------------
 
 3. Clearly, an implicitly declared dispatching "/=" should not
 automatically be illegal.
@@ -333,9 +330,9 @@
 of it.  6.3.1(8) applies to those cases where the actual type might be
 class-wide, and makes these Intrinsic, thus forbidding 'Access.
 
-The wording change to 3.9.2(10) shown above means that it's OK to have
-such an inherited subprogram.  If the spec of G contained a type
-extension of Formal, then that type's inherited Proc would also have
+The wording change to 3.9.2(10) shown above means that it is permitted
+to have such an inherited subprogram.  If the specification of G contained a
+type extension of Formal, then that type's inherited Proc would also have
 convention Intrinsic, which would be legal. However, an explicit
 overriding of that Proc would be illegal.
 
@@ -349,7 +346,7 @@
 subtype conformant with the inherited subprogram. A dispatching operation
 shall not be of convention Intrinsic. If a dispatching operation overrides
 the predefined equals operator, then it shall be of convention Ada (either
-explicitly or by default -- see 6.3.1).
+explicitly or by default @emdash see 6.3.1).
 @dby
 In the declaration of a dispatching operation of a tagged type,
 everywhere a subtype of the tagged type appears as a subtype of the profile
@@ -363,15 +360,15 @@
 !corrigendum 6.03.01(2)
 
 @drepl
-As explained in B.1, ``Interfacing Pragmas'', a @i<convention> can be
-specified for an entity. For a callable entity
+As explained in B.1, @lquote@lquoteInterfacing Pragmas@rquote@rquote, a
+@i<convention> can be specified for an entity. For a callable entity
 or access-to-subprogram type, the convention is called the
 @i<calling convention>. The following conventions are defined by the language:
 @dby
-As explained in B.1, ``Interfacing Pragmas'', a @i<convention> can be
-specified for an entity. Unless this International Standard states
-otherwise, the default convention of an entity is Ada. For a callable entity
-or access-to-subprogram type, the convention is called the
+As explained in B.1, @lquote@lquoteInterfacing Pragmas@rquote@rquote, a
+@i<convention> can be specified for an entity. Unless this International
+Standard states otherwise, the default convention of an entity is Ada. For
+a callable entity or access-to-subprogram type, the convention is called the
 @i<calling convention>. The following calling conventions are defined by the
 language:
 
@@ -454,7 +451,7 @@
 !reference 95-5394.a Tucker Taft 95-11-21>>
 !discussion
 
-If an Ada 95 implementation is tightly integrated with another
+If an Ada implementation is tightly integrated with another
 language, such as C++ or Java, it is nice if an Ada tagged type
 can be declared as an extension of a (foreign) type (or class) of the
 other language.  Presumably, all of the dispatching operations of this

Questions? Ask the ACAA Technical Agent