CVS difference for ais/ai-00231.txt

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

--- ais/ai-00231.txt	2005/06/16 23:47:13	1.22
+++ ais/ai-00231.txt	2005/08/21 06:00:16	1.23
@@ -1,4 +1,4 @@
-!standard  3.10      (06)                        05-05-10  AI95-00231/15
+!standard  3.10      (06)                        05-07-11  AI95-00231/16
 !standard  3.2       (07)
 !standard  3.2       (08)
 !standard  3.2.2     (03)
@@ -20,6 +20,7 @@
 !standard  6.1       (23)
 !standard  6.1       (24)
 !standard  6.4       (12)
+!standard  7.4       (07)
 !standard  8.5.1     (04)
 !standard  8.6       (20)
 !standard  8.6       (25)
@@ -72,8 +73,8 @@
 
 Add to the penultimate sentence of 3.2(8):
 
-...of the values of its type that satisfy its constraint {and, in the case of a
-subtype that excludes null, the values do not include the null value}.
+...of the values of its type that satisfy its constraint {and any exclusion
+of the null value}.
 
 Replace paragraph 3.2.2(3) with:
     subtype_indication ::=
@@ -135,17 +136,14 @@
 
 Add after 3.10(13):
 
-   A null_exclusion in an access_definition, access_type_definition,
-   subtype_indication (see 3.2.2), discriminant_specification (see 3.7),
-   parameter_specification (see 6.1), parameter_and_result_profile (see 6.1),
-   object_renaming_declaration (see 8.5.1), or formal_object_declaration (see
-   12.4) specifies that the null value does not belong to the access subtype
-   defined by the construct, that is, the access subtype *excludes null*. In
-   addition, the anonymous access subtype defined by the access_definition for
-   a controlling access parameter (see 3.9.2) excludes null. Finally, for a
-   subtype_indication without a null_exclusion, the subtype denoted by the
-   subtype_indication excludes null if and only if the subtype denoted by the
-   subtype_mark in the subtype_indication does.
+   A null_exclusion in a construct specifies that the null value does not
+   belong to the access subtype defined by the construct, that is, the access
+   subtype *excludes null*. In addition, the anonymous access subtype defined
+   by the access_definition for a controlling access parameter (see 3.9.2)
+   excludes null. Finally, for a subtype_indication without a null_exclusion,
+   the subtype denoted by the subtype_indication excludes null if and only if
+   the subtype denoted by the subtype_mark in the subtype_indication excludes
+   null.
 
    AARM Note: Controlling access_definitions exclude null because it
    is necessary to read the tag to dispatch, and null has no tag. We
@@ -156,11 +154,11 @@
 
             Legality Rules
 
-    A null_exclusion is only allowed in a subtype_indication,
-    discriminant_specification, parameter_specification,
-    parameter_and_result_profile, object_renaming_declaration, or
-    formal_object_declaration whose subtype_mark
-    denotes an access subtype that does not exclude null.
+    If a subtype_indication, discriminant_specification,
+    parameter_specification, parameter_and_result_profile,
+    object_renaming_declaration, or formal_object_declaration has a
+    null_exclusion, the subtype_mark in that construct shall denote an access
+    subtype that does not exclude null.
 
 Modify 3.10(15) as follows:
 
@@ -169,9 +167,8 @@
     compatible with any access subtype that does not exclude null.} An
     access value satisfies a composite_constraint of an access subtype if it
     equals the null value of its type or if it designates an object whose value
-    satisfies the constraint. {An access value satisfies an access
-    subtype that excludes null if it does not equal the null value of its
-    type.}
+    satisfies the constraint. {An access value satisfies an exclusion of
+    the null value if it does not equal the null value of its type.}
 
 Delete paragraph 4.2(7) which says that anonymous access types don't
 have a null value.
@@ -233,6 +230,10 @@
     ...the nominal subtype of the constant is given by
     the {nominal}[result] subtype of the function{ result}.
 
+Add after 7.4(7):
+  * If the subtype of the deferred constant declaration excludes null, the
+    subtype of the full declaration shall also exclude null.
+
 Add to the end of 8.5.1(4), if AI-230 is adopted:
     In the case where the type is defined by an access_definition,
     the renamed entity shall be of an access-to-constant type if and
@@ -442,9 +443,8 @@
 Similarly, the associated constraint is called the
 constraint @i<of> the subtype. The set of values
 of a subtype consists of the values of its type
-that satisfy its constraint and, in the case
-of a subtype that excludes null, the values do not
-include the null value. Such values @i<belong> to the subtype.
+that satisfy its constraint and any exclusion of the null value.
+Such values @i<belong> to the subtype.
 
 !corrigendum 3.2.2(3)
 
@@ -543,19 +543,15 @@
 which returns an access value designating a newly created object (see 3.10.2).
 @dby
 For each access type, there is a null access value designating no entity at
-all, which can be obtained by converting the literal @b<null> to the access
-type. The null value of an access type is the default initial value of the type.
-Non-null values of an access type are obtained by evaluating an
-@fa<attribute_reference> for the Access or Unchecked_Access attribute of
-a non-intrinsic subprogram or an aliased view of an object, or, in the
-case of an access-to-object type, an @fa<allocator>, which returns an
-access value designating a newly created object (see 3.10.2).
-
-A @fa<null_exclusion> in an @fa<access_definition>, @fa<access_type_definition>,
-@fa<subtype_indication> (see 3.2.2), @fa<discriminant_specification> (see 3.7),
-@fa<parameter_specification> (see 6.1),
-@fa<parameter_and_result_profile> (see 6.1), @fa<object_renaming_declaration>
-(see 8.5.1), or @fa<formal_object_declaration> (see 12.4) specifies that the
+all, which can be obtained by (implicitly) converting the literal @b<null> to
+the access type. The null value of an access type is the default initial value
+of the type. Non-null values of an access type are obtained by evaluating an
+@fa<attribute_reference> for the Access or Unchecked_Access attribute of a
+non-intrinsic subprogram or an aliased view of an object, or, in the case of an
+access-to-object type, an @fa<allocator>, which returns an access value
+designating a newly created object (see 3.10.2).
+
+A @fa<null_exclusion> in a construct specifies that the
 null value does not belong to the access subtype defined by the construct, that
 is, the access subtype @i<excludes null>. In addition, the anonymous access
 subtype defined by the @fa<access_definition> for a controlling access
@@ -563,7 +559,7 @@
 Finally, for a @fa<subtype_indication> without a @fa<null_exclusion>,
 the subtype denoted by the @fa<subtype_indication> excludes null if and
 only if the subtype denoted by the @fa<subtype_mark> in the
-@fa<subtype_indication> does.
+@fa<subtype_indication> excludes null.
 
 !corrigendum 3.10(14/1)
 
@@ -578,9 +574,15 @@
 A @fa<null_exclusion> is only allowed in a @fa<subtype_indication>,
 @fa<discriminant_specification>, @fa<parameter_specification>,
 @fa<parameter_and_result_profile>, @fa<object_renaming_declaration>, or
-@fa<formal_object_declaration> whose @fa<subtype_mark>
+@fa<formal_object_declaration> if the @fa<subtype_mark> in the construct
 denotes an access subtype that does not exclude null.
 
+If a @fa<subtype_indication>, @fa<discriminant_specification>,
+@fa<parameter_specification>, @fa<parameter_and_result_profile>,
+@fa<object_renaming_declaration>, or @fa<formal_object_declaration> has a
+@fa<null_exclusion>, the @fa<subtype_mark> in that construct shall denote
+an access subtype that does not exclude null.
+
 !corrigendum 3.10(15)
 
 @drepl
@@ -595,8 +597,8 @@
 is compatible with any access subtype that does not exclude null. An
 access value @i<satisfies> a @fa<composite_constraint> of an access subtype if
 it equals the null value of its type or if it designates an object whose value
-satisfies the constraint. An access value satisfies an access subtype that
-excludes null if it does not equal the null value of its type.
+satisfies the constraint. An access value satisfies an exclusion of the null
+value if it does not equal the null value of its type.
 
 !corrigendum 4.2(7)
 
@@ -717,6 +719,18 @@
 @dby
 A @fa<function_call> denotes a constant, as defined in 6.5; the nominal subtype
 of the constant is given by the nominal subtype of the function result.
+
+!corrigendum 7.4(7)
+
+@drepl
+@xbullet<If deferred constant declaration includes the reserved word
+@b<aliased>, then the full declaration shall also.>
+@dby
+@xbullet<If deferred constant declaration includes the reserved word
+@b<aliased>, then the full declaration shall also;>
+
+@xbullet<If the subtype of the deferred constant declaration excludes null, the
+subtype of the full declaration shall also exclude null.>
 
 !corrigendum 8.5.1(4)
 

Questions? Ask the ACAA Technical Agent