CVS difference for ai05s/ai05-0228-1.txt

Differences between 1.7 and version 1.8
Log of other versions for file ai05s/ai05-0228-1.txt

--- ai05s/ai05-0228-1.txt	2011/04/11 23:57:16	1.7
+++ ai05s/ai05-0228-1.txt	2011/05/07 00:35:51	1.8
@@ -1,9 +1,10 @@
-!standard 3.3.1(11)                                    11-03-11  AI05-0228-1/04
-!standard 3.3.1(12)
+!standard 3.3.1(11)                                    11-05-05  AI05-0228-1/05
+!standard 3.3.1(13)
 !standard 3.3.1(21)
 !standard 3.5(56/2)
 !standard 3.6(22/2)
 !standard 6.4.1(13)
+!standard 13.13.2(35/2)
 !class Amendment 10-10-22
 !status Amendment 2012 11-03-11
 !status ARG Approved  7-0-0  11-02-19
@@ -71,8 +72,8 @@
 There is no implicit initial value for a scalar subtype{ unless the
 Default_Value aspect has been specified for the type}. In the absence of an
 explicit initialization{ or the specification of the Default_Value
-aspect}, a newly created scalar object might have a value that does not belong
-to its subtype (see 13.9.1 and H.1).
+aspect}, a newly created scalar object might have a value that does
+not belong to its subtype (see 13.9.1 and H.1).
 
 Add after 3.5(56/2):
 
@@ -104,7 +105,7 @@
   Name Resolution
 
 The expected type for the expression specified for the Default_Value aspect is
-the type defined by the full_type_declaration.
+the type defined by the full_type_declaration on which it appears.
 
 Add after 3.6(22/2):
 
@@ -126,12 +127,13 @@
 aspect, the aspect may be specified to have any value for the derived type.
 
 AARM Reason: This is to override the 13.3.1 rule that says that a boolean aspect
-with a value True cannot be changed.
+with a value True cannot be changed for a derived type.
 
   Name Resolution
 
 The expected type for the expression specified for the Default_Component_Value aspect
-is the component type of the array type defined by the full_type_declaration.
+is the component type of the array type defined by the full_type_declaration on which
+it appears.
 
 
 Add a new bullet after 6.4.1(13): [Note that 6.4.1(13) was modified by AI05-0196-1 --
@@ -181,12 +183,12 @@
 check fails.
 
 AARM To Be Honest: An implementation should always be able to detect the
-error for an access subtype with a null exclusion; the "if the implementation can detect"
-is intended to cover non-null access values.
+error for a null value read into an access subtype with a null exclusion; the "if the
+implementation can detect" is intended to cover non-null access values.
 
 AARM Ramification: A scalar component can have an implicit initial value if it has a
 default_expression, if the component's type has the Default_Value aspect specified,
-or if the component is that of an array type that have the Default_Component_Value
+or if the component is that of an array type that has the Default_Component_Value
 aspect specified.
 
 !discussion
@@ -216,6 +218,151 @@
 
    type Blank_String is array (Positive range <>) of Character with
       Default_Component_Value => ' ';
+
+!corrigendum 3.3.1(11)
+
+@dinsa
+@xbullet<The implicit initial value for an access subtype is the null value of the
+access type.>
+@dinst
+@xbullet<The implicit initial value for a scalar subtype that has the Default_Value
+aspect specified is the value of that aspect converted to the nominal subtype
+(which might raise Constraint_Error @emdash see 4.6, “Type Conversions”);>
+
+!corrigendum 3.3.1(13)
+
+@drepl
+For a (definite) composite subtype, the implicit initial value of each component
+with a @fa<default_expression> is obtained by evaluation of this expression and
+conversion to the component's nominal subtype (which might raise Constraint_Error
+@emdash see 4.6, "Type Conversions"), unless the component is a discriminant of a
+constrained subtype (the previous case), or is in an excluded @fa<variant> (see 3.8.1).
+For each component that does not have a @fa<default_expression>, any implicit initial
+values are those determined by the component's nominal subtype.
+@dby
+For a (definite) composite subtype, the implicit initial value of each component
+with a @fa<default_expression> is obtained by evaluation of this expression and
+onversion to the component's nominal subtype (which might raise Constraint_Error),
+unless the component is a discriminant of a constrained subtype (the previous case),
+or is in an excluded @fa<variant> (see 3.8.1).
+For each component that does not have a @fa<default_expression>, if the composite
+subtype has the Default_Component_Value aspect specified, the implicit initial value
+is the value of that aspect converted to the component's nominal subtype;
+otherwise, any implicit initial values are those determined by the component's
+nominal subtype.
+
+!corrigendum 3.3.1(21)
+
+@drepl
+There is no implicit initial value defined for a scalar subtype. In the absence of
+an explicit initialization, a newly created scalar object might have a value that
+does not belong to its subtype (see 13.9.1 and H.1). 
+@dby
+There is no implicit initial value for a scalar subtype unless the
+Default_Value aspect has been specified for the type. In the absence of an
+explicit initialization or the specification of the Default_Value
+aspect, a newly created scalar object might have a value that does
+not belong to its subtype (see 13.9.1 and H.1).
+
+!corrigendum 3.5(56/2)
+
+@dinsa
+An implementation may extend the Wide_Wide_Value, Wide_Value, Value, Wide_Wide_Image,
+Wide_Image, and Image attributes of a floating point type to support special values
+such as infinities and NaNs.
+@dinss
+@s8<@i<Static Semantics>>
+
+For a scalar type, the following language-defined representation aspect
+may be specified with an @fa<aspect_specification> (see 13.3.1):
+@xhang<@xterm<Default_Value>
+This aspect shall be specified by a static expression, and that
+expression shall be explicit, even if the aspect has a boolean type.
+Default_Value shall be specified only on a @fa<full_type_declaration>.>
+
+If a derived type with no primitive subprograms inherits a boolean Default_Value
+aspect, the aspect may be specified to have any value for the derived type.
+
+@s8<@i<Name Resolution Rules>>
+
+The expected type for the @fa<expression> specified for the Default_Value aspect is
+the type defined by the @fa<full_type_declaration> on which it appears.
+
+
+!corrigendum 3.6(22)
+
+@dinsa
+The elaboration of a @fa<discrete_subtype_definition> that does not contain any
+per-object expressions creates the discrete subtype, and consists of the elaboration
+of the @fa<subtype_indication> or the evaluation of the @fa<range>. The elaboration
+of a @fa<discrete_subtype_definition> that contains one or more per-object expressions
+is defined in 3.8. The elaboration of a @fa<component_definition> in an
+@fa<array_type_definition> consists of the elaboration of the @fa<subtype_indication>
+or @fa<access_definition>. The elaboration of any @fa<discrete_subtype_definition>s
+and the elaboration of the @fa<component_definition> are performed in an arbitrary order. 
+@dinss
+@s8<@i<Static Semantics>>
+
+For an array type with a scalar component type, the following
+language-defined representation aspect may be specified with an
+@fa<aspect_specification> (see 13.3.1):
+@xhang<@xterm<Default_Component_Value>
+This aspect shall be specified by a static expression, and that
+expression shall be explicit, even if the aspect has a boolean type.
+Default_Component_Value shall be specified only on a @fa<full_type_declaration>.>
+
+If a derived type with no primitive subprograms inherits a boolean Default_Value
+aspect, the aspect may be specified to have any value for the derived type.
+
+@s8<@i<Name Resolution Rules>>
+
+The expected type for the expression specified for the Default_Component_Value aspect
+is the component type of the array type defined by the @fa<full_type_declaration> on
+which it appears.
+
+!corrigendum 6.4.1(13)
+
+@dinsa
+For an access type, the formal parameter is initialized from the value of the actual,
+without a constraint check; 
+@dinst
+For a scalar type that has the Default_Value aspect specified, the formal parameter
+is initialized from the value of the actual, without checking that the value satisfies
+any constraint;
+
+!corrigendum 13.13.2(35)
+
+@drepl
+In the default implementation of Read and Input for a composite type, for each
+scalar component that is a discriminant or whose @fa<component_declaration>
+includes a @fa<default_expression>, a check is made that the value returned by
+Read for the component belongs to its subtype. Constraint_Error is raised if
+this check fails. For other scalar components, no check is made. For each
+component that is of an access type, if the implementation can detect that
+the value returned by Read for the component is not a value of its subtype,
+Constraint_Error is raised. If the value is not a value of its subtype and
+this error is not detected, the component has an abnormal value, and erroneous
+execution can result (see 13.9.1). In the default implementation of Read for a
+composite type with defaulted discriminants, if the actual parameter of Read is
+constrained, a check is made that the discriminants read from the stream are
+equal to those of the actual parameter. Constraint_Error is raised if this
+check fails.
+@dby
+In the default implementation of Read and Input for a composite type, for each
+scalar component that is a discriminant or that has an implicit initial value,
+a check is made that the value returned by
+Read for the component belongs to its subtype. Constraint_Error is raised if
+this check fails. For other scalar components, no check is made. For each
+component that is of an access type, if the implementation can detect that
+the value returned by Read for the component is not a value of its subtype,
+Constraint_Error is raised. If the value is not a value of its subtype and
+this error is not detected, the component has an abnormal value, and erroneous
+execution can result (see 13.9.1). In the default implementation of Read for a
+composite type with defaulted discriminants, if the actual parameter of Read is
+constrained, a check is made that the discriminants read from the stream are
+equal to those of the actual parameter. Constraint_Error is raised if this
+check fails.
+
 
 !ACATS test
 

Questions? Ask the ACAA Technical Agent