CVS difference for ais/ai-00345.txt

Differences between 1.21 and version 1.22
Log of other versions for file ais/ai-00345.txt

--- ais/ai-00345.txt	2005/06/16 23:47:31	1.21
+++ ais/ai-00345.txt	2005/08/21 06:00:31	1.22
@@ -1,4 +1,4 @@
-!standard  3.09.01    (03)                             05-06-05  AI95-00345/09
+!standard  3.09.01    (03)                             05-07-25  AI95-00345/10
 !standard  2.09       (02)
 !standard  3.02       (12)
 !standard  3.02       (13)
@@ -8,12 +8,14 @@
 !standard  3.09.03    (02)
 !standard  3.09.04    (01)
 !standard  6.03.01    (24)
+!standard  8.03       (18)
 !standard  9.01       (02)
 !standard  9.01       (08)
 !standard  9.01       (09.1/1)
 !standard  9.04       (02)
 !standard  9.04       (10)
 !standard  9.04       (11)
+!standard  9.05       (07)
 !standard  9.07.02    (01)
 !standard  9.07.02    (03)
 !standard  9.07.02    (04)
@@ -22,7 +24,6 @@
 !standard  9.08       (03)
 !standard  9.09       (01)
 !standard 12.05.05    (01)
-!standard 12.06       (09)
 !class amendment 03-08-07
 !status Amendment 200Y 04-07-02
 !status WG9 approved 04-11-18
@@ -340,21 +341,27 @@
     The parent type of a record extension shall not be a class-wide type {nor
     shall it be a synchronized tagged type (see 3.9.4)}.
 
-Change 3.9.2(20) as follows:
+Replace 3.9.2(20) by:
 
-    For the execution of a call on a dispatching operation, the body executed
-    is the one for the corresponding primitive subprogram of the specific type
-    identified by the controlling tag value. The body for an explicitly
-    declared dispatching operation is the corresponding explicit body for the
-    subprogram. The body for an implicitly declared dispatching operation that
-    is overridden is the body for the overriding subprogram, Redunant[even if
-    the overriding occurs in a private part.] {Similarly, the body for an
-    implicitly declared dispatching operation that is implemented by an
-    entry (see 9.1) or protected operation (see 9.4) is the body for the
-    implemented entry or operation.} The body for an inherited dispatching
-    operation that is not overridden {or implemented} is the body of the
-    corresponding subprogram of the parent or ancestor type.
+    For the execution of a call on a dispatching operation, the action
+    performed is determined by the properties of the corresponding
+    dispatching operation of the specific type identified by the
+    controlling tag value. If the corresponding operation is explicitly
+    declared for this type, Redundant[even if the declaration occurs in
+    a private part], then the action comprises an invocation of the
+    explicit body for the operation.  If the corresponding operation is
+    implicitly declared for this type:
+
+      * if the operation is implemented by an entry or protected
+        subprogram (see 9.1 and 9.4), then the action comprises a call
+        on this entry or protected subprogram, with the target object
+        being given by the first actual parameter of the call, and the
+        actual parameters of the entry or protected subprogram being
+        given by the remaining actual parameters of the call, if any;
 
+      * otherwise, the action is the same as the action for the
+        corresponding operation of the parent type.
+
 Replace the first sentence of 3.9.3(1) with:
 
     An abstract type is a tagged type intended for use as an ancestor of
@@ -435,6 +442,27 @@
     type conformant (respectively mode conformant, subtype conformant, or fully
     conformant).
 
+Change 6.4(10) as follows:
+    For the execution of a subprogram call, the name or prefix of the call is
+    evaluated, and each parameter_association is evaluated (see 6.4.1). If a
+    default_expression is used, an implicit parameter_association is assumed
+    for this rule. These evaluations are done in an arbitrary order. The
+    subprogram_body is then executed{, or a call on an entry or protected
+    subprogram is performed (see 3.9.2)}. Finally, if the subprogram {or entry}
+    completes normally, then after it is left, any necessary assigning back of
+    formal to actual parameters occurs (see 6.4.1).
+
+Replace 8.3(18) by:
+
+  * For a package_declaration, generic_package_declaration, or subprogram_body,
+    the declaration is hidden from all visibility only until the reserved word
+    is of the declaration;
+
+  * For a task declaration or protected declaration, the declaration is hidden
+    from all visibility only until the reserved word with of the
+    declaration if there is one, or the reserved word is of the declaration
+    if there is no with.
+
 Change 9.1(2) to:
 
   task_type_declaration ::=
@@ -532,6 +560,16 @@
 of mode OUT or IN OUT, or an access-to-variable parameter.
 
 
+Add after 9.5(7):
+    The view of the target protected object associated with a call of a
+    protected procedure or entry shall be a variable.
+
+[This rule is missing in Ada 95, although it can be implied from 9.5(9)
+and 3.3(13). Many compilers have failed to check for this, probably because
+there is no legality rule, like the ones in 6.4.1(5) and 5.2(5). It also
+seems odd to have the rule above for "implemented by" calls, and no similar
+rule for normal calls.]
+
 Add at end of 9.7.2(1) and 9.7.3(1):
 
     A procedure call may appear rather than an entry call for cases
@@ -551,7 +589,7 @@
 
     If a procedure_call_statement is used for a procedure_or_entry_call,
     the procedure_name or procedure_prefix of the procedure_call_statement
-    shall denote an entry renamed as a procedure, a formal subprogram, or
+    shall statically denote an entry renamed as a procedure or
     (a view of) a primitive subprogram of a limited interface whose first
     parameter is a controlling parameter (see 3.9.2).
 
@@ -578,8 +616,8 @@
     delay_expression of the delay_alternative. {If the call is an entry call or
     a call on a procedure implemented by an entry,} the entry call is then
     issued. {Otherwise, the call proceeds as described in 6.4 for a procedure
-    call, followed by the sequence_of_statements of the entry_call_alternative,
-    and the sequence_of_statements of the delay_alternative is ignored.}
+    call, followed by the sequence_of_statements of the entry_call_alternative;
+    the sequence_of_statements of the delay_alternative is ignored.}
 
 Modify 9.7.4(4): change "entry_call_statement" to "procedure_or_entry_call"
 
@@ -595,7 +633,7 @@
     call is selected immediately, and never requeued-with-abort, then the
     abortable_part is never started. {If the call is on a procedure that is
     not implemented by an entry, the call proceeds as described in 6.4,
-    followed by the sequence_of_statements of the triggering_alternative, and
+    followed by the sequence_of_statements of the triggering_alternative;
     the abortable_part is never started.}
 
 Modify 9.8(3):
@@ -623,10 +661,6 @@
 
 [end of AI-251-relative changes]
 
-Delete the last sentence of 12.6(9) since the view can be used as an entry:
-
-[The view is a function or procedure, never an entry.]
-
 !example
 
     package Example is
@@ -1143,19 +1177,22 @@
 operation that is not overridden is the body of the
 corresponding subprogram of the parent or ancestor type.
 @dby
-For the execution of a call on a dispatching operation, the body executed
-is the one for the corresponding primitive subprogram of the specific type
-identified by the controlling tag value. The body for an explicitly
-declared dispatching operation is the corresponding explicit body for the
-subprogram. The body for an implicitly declared dispatching operation that
-is overridden is the body for the overriding subprogram, even if
-the overriding occurs in a private part. Similarly, the body for an
-implicitly declared dispatching operation that is implemented by an
-entry (see 9.1) or protected operation (see 9.4) is the body for the
-implemented entry or operation. The body for an inherited dispatching
-operation that is not overridden or implemented is the body of the
-corresponding subprogram of the parent or ancestor type.
+For the execution of a call on a dispatching operation, the action performed is
+determined by the properties of the corresponding dispatching operation of the
+specific type identified by the controlling tag value. If the corresponding
+operation is explicitly declared for this type, Redundant[even if the
+declaration occurs in a private part], then the action comprises an invocation
+of the explicit body for the operation. If the corresponding operation is
+implicitly declared for this type:
+
+@xbullet<if the operation is implemented by an entry or protected subprogram
+(see 9.1 and 9.4), then the action comprises a call on this entry or protected
+subprogram, with the target object being given by the first actual parameter of
+the call, and the actual parameters of the entry or protected subprogram being
+given by the remaining actual parameters of the call, if any;>
 
+@xbullet<otherwise, the action is the same as the action for the corresponding
+operation of the parent type.>
 
 !corrigendum 3.9.3(1)
 
@@ -1213,6 +1250,43 @@
 are type conformant (respectively mode conformant, subtype conformant, or fully
 conformant).
 
+!corrigendum 6.4(10)
+
+@drepl
+For the execution of a subprogram call, the @fa<name> or @fa<prefix> of the
+call is evaluated, and each @fa<parameter_association> is evaluated (see
+6.4.1). If a @fa<default_expression> is used, an implicit
+@fa<parameter_association> is assumed for this rule. These evaluations are done
+in an arbitrary order. The @fa<subprogram_body> is then executed. Finally, if
+the subprogram completes normally, then after it is left, any necessary
+assigning back of formal to actual parameters occurs (see 6.4.1).
+@dby
+For the execution of a subprogram call, the @fa<name> or @fa<prefix> of the
+call is evaluated, and each @fa<parameter_association> is evaluated (see
+6.4.1). If a @fa<default_expression> is used, an implicit
+@fa<parameter_association> is assumed for this rule. These evaluations are done
+in an arbitrary order. The @fa<subprogram_body> is then executed, or a call on
+an entry or protected subprogram is performed (see 3.9.2). Finally, if the
+subprogram completes normally, then after it is left, any necessary assigning
+back of formal to actual parameters occurs (see 6.4.1).
+
+!corrigendum 8.3(18)
+
+@drepl
+@xinbull<For a @fa<package_declaration>, task declaration,
+protected declaration, @fa<generic_package_declaration>, or @fa<subprogram_body>,
+the declaration is hidden from all visibility only until the reserved word
+@b<is> of the declaration.>
+@dby
+@xinbull<For a @fa<package_declaration>, @fa<generic_package_declaration>,
+or @fa<subprogram_body>, the declaration is hidden from all visibility only
+until the reserved word @b<is> of the declaration;>
+
+@xinbull<For a task declaration or protected declaration,
+the declaration is hidden from all visibility only
+until the reserved word @b<with> of the declaration if there is one, or the
+reserved word @b<is> of the declaration if there is no @b<with>.>
+
 !corrigendum 9.1(2)
 
 @drepl
@@ -1351,6 +1425,16 @@
 an entry, then the first parameter of the inherited subprogram shall be
 of mode @b<out> or @b<in out>, or an access-to-variable parameter.
 
+!corrigendum 9.5(7)
+
+@dinsa
+A corresponding definition of target object applies to a @fa<requeue_statement>
+(see 9.5.4), with a corresponding distinction between an @i<internal requeue>
+and an @i<external requeue>.
+@dinst
+The view of the target protected object associated with a call of a
+protected procedure or entry shall be a variable.
+
 !corrigendum 9.7.2(1)
 
 @drepl
@@ -1379,9 +1463,9 @@
 
 If a @fa<procedure_call_statement> is used for a @fa<procedure_or_entry_call>,
 the @i<procedure_>@fa<name> or @i<procedure_>@fa<prefix> of the
-@fa<procedure_call_statement> shall denote an entry renamed as a procedure, a
-formal subprogram, or (a view of) a primitive subprogram of a limited interface
-whose first parameter is a controlling parameter (see 3.9.2).
+@fa<procedure_call_statement> shall statically denote an entry renamed as a
+procedure or (a view of) a primitive subprogram of a limited interface whose
+first parameter is a controlling parameter (see 3.9.2).
 
 @i<@s8<Static Semantics>>
 
@@ -1408,7 +1492,7 @@
 call is an entry call or a call on a procedure implemented by an entry, the
 entry call is then issued. Otherwise, the call proceeds as described in 6.4 for
 a procedure call, followed by the @fa<sequence_of_statements> of the
-@fa<entry_call_alternative>, and the @fa<sequence_of_statements> of the
+@fa<entry_call_alternative>; the @fa<sequence_of_statements> of the
 @fa<delay_alternative> is ignored.
 
 !corrigendum 9.7.3(1)
@@ -1451,7 +1535,7 @@
 requeued-with-abort, then the @fa<abortable_part> is never started. If the call
 is on a procedure that is not implemented by an entry, the call proceeds as
 described in 6.4, followed by the @fa<sequence_of_statements> of the
-@fa<triggering_alternative>, and the @fa<abortable_part> is never started.
+@fa<triggering_alternative>; the @fa<abortable_part> is never started.
 
 !corrigendum 9.8(3)
 
@@ -1479,38 +1563,6 @@
 @dinsc
 The class determined for a formal interface type is the class of all
 interface types.
-
-!corrigendum 12.6(9)
-
-@drepl
-A @fa<formal_subprogram_declaration> declares a generic formal subprogram. The
-types of the formal parameters and result, if any, of the formal subprogram are
-those determined by the @fa<subtype_mark>s given in the
-@fa<formal_subprogram_declaration>; however, independent of the particular
-subtypes that are denoted by the @fa<subtype_mark>s, the nominal subtypes of
-the formal parameters and result, if any, are defined to be nonstatic, and
-unconstrained if of an array type (no applicable index constraint is provided
-in a call on a formal subprogram). In an instance, a
-@fa<formal_subprogram_declaration> declares a view of the actual. The profile
-of this view takes its subtypes and calling convention from the original
-profile of the actual entity, while taking the formal parameter @fa<name>s and
-@fa<default_expression>s from the profile given in the
-@fa<formal_subprogram_declaration>. The view is a function or procedure, never
-an entry.
-@dby
-A @fa<formal_subprogram_declaration> declares a generic formal subprogram. The
-types of the formal parameters and result, if any, of the formal subprogram are
-those determined by the @fa<subtype_mark>s given in the
-@fa<formal_subprogram_declaration>; however, independent of the particular
-subtypes that are denoted by the @fa<subtype_mark>s, the nominal subtypes of
-the formal parameters and result, if any, are defined to be nonstatic, and
-unconstrained if of an array type (no applicable index constraint is provided
-in a call on a formal subprogram). In an instance, a
-@fa<formal_subprogram_declaration> declares a view of the actual. The profile
-of this view takes its subtypes and calling convention from the original
-profile of the actual entity, while taking the formal parameter @fa<name>s and
-@fa<default_expression>s from the profile given in the
-@fa<formal_subprogram_declaration>.
 
 !ACATS test
 

Questions? Ask the ACAA Technical Agent