CVS difference for ais/ai-00051.txt

--- ais/ai-00051.txt	2004/08/31 23:06:00	1.6
+++ ais/ai-00051.txt	2004/10/05 22:48:57	1.7
@@ -1,5 +1,15 @@
-!standard 13.03    (42)                               04-08-31  AI95-00051/12
+!standard 13.03    (25)                               04-09-27  AI95-00051/13
+!standard 13.03    (28)
+!standard 13.03    (30)
+!standard 13.03    (31)
+!standard 13.03    (32)
+!standard 13.03    (42)
+!standard 13.03    (43)
+!standard 13.03    (50)
+!standard 13.03    (56)
 !class binding interpretation 95-06-25
+!status Amendment 200Y 04-09-27
+!status ARG Approved 8-0-1  04-09-18
 !status work item 98-04-01
 !status ARG Approved (subject to letter ballot)  8-0-2  97-11-14
 !status work item (letter ballot was 4-4-3) 96-10-03
@@ -66,7 +76,7 @@
     "If the Alignment of a subtype is specified, then the Alignment of an object is
      at least as strict, unless the object's Alignment is also specified".
 with
-    "The Alignment of an object is as at least as strict as the alignment
+    "The Alignment of an object is at least as strict as the alignment
      of its subtype, unless the object's Alignment is specified".
 
 Replace 13.3(28) with
@@ -109,11 +119,12 @@
       integer type specifying a Size greater than the largest Size
       value that would be chosen by default (i.e. in the absence of a
       Size clause) for any signed integer type. Corresponding advice
-      applies for modular integer types, fixed point types, enumeration
-      types, record types, and array types.
+      applies for modular integer types, fixed point types, and enumeration
+      types.
 
-    - For floating point types, access types, protected types, and task types,
-      an implementation need not support a nonconfirming Size clause.
+    - For floating point types, access types, array types, record types,
+      protected types, and task types, an implementation need not support a
+      nonconfirming Size clause.
 
 !discussion
 
@@ -147,6 +158,120 @@
 
     type T4 is new Integer;
     for T4'Alignment use 3;  -- Need not be supported
+
+!corrigendum 13.3(25)
+
+@drepl
+@xindent<Alignment may be specified for first subtypes and stand-alone objects
+via an @fa<attribute_definition_clause>; the expression of such a clause shall
+be static, and its value nonnegative. If the Alignment of a subtype is
+specified, then the Alignment of an object of the subtype is at least as
+strict, unless the object's Alignment is also specified. The Alignment of an
+object created by an allocator is that of the designated subtype.>
+@dby
+@xindent<Alignment may be specified for first subtypes and stand-alone objects
+via an @fa<attribute_definition_clause>; the expression of such a clause shall
+be static, and its value nonnegative. The Alignment of an object is at least as
+strict as the alignment of its subtype, unless the object's Alignment is
+specified. The Alignment of an object created by an allocator is that of the
+designated subtype.>
+
+!corrigendum 13.3(28)
+
+@drepl
+If the Alignment is specified for an object that is not allocated under control
+of the implementation, execution is erroneous if the object is not aligned
+according to the Alignment.
+@dby
+Program execution is erroneous if an object that is not allocated under
+control of the implementation is not aligned according to its Alignment.
+
+
+!corrigendum 13.3(30)
+
+@drepl
+@xbullet<An implementation should support specified Alignments that are factors
+and multiples of the number of storage elements per word, subject to the
+following:>
+@dby
+@xbullet<An implementation need not support a nonconfirming Alignment clause
+specifying an Alignment which is neither zero nor a power of two.>
+
+!corrigendum 13.3(31)
+
+@drepl
+@xbullet<An implementation need not support specified Alignments for
+combinations of Sizes and Alignments that cannot be easily loaded and stored by
+available machine instructions.>
+@dby
+@xbullet<An implementation need not support an Alignment clause for a signed
+integer type specifying an Alignment greater than the largest Alignment value
+that would be chosen by default by the implementation for any signed integer
+type. Corresponding advice applies for modular integer types, fixed point
+types, enumeration types, record types, and array types.>
+
+@xbullet<For floating point types, access types, protected types, and task
+types, an implementation need not support a nonconfirming Alignment clause.>
+
+!corrigendum 13.3(32)
+
+@drepl
+@xbullet<An implementation need not support specified Alignments that are
+greater than the maximum Alignment the implementation ever returns by default.>
+@dby
+@xbullet<An implementation need not support a nonconfirming Alignment clause
+which could enable the creation of an elementary object which cannot be easily
+loaded and stored by available machine instructions.>
+
+!corrigendum 13.3(42)
+
+@drepl
+The recommended level of support for the Size attribute of objects is:
+@dby
+The recommended level of support for the Size attribute of objects is
+the same as for subtypes (see below).
+
+!corrigendum 13.3(43)
+
+@ddel
+@xbullet< A Size clause should be supported for an object if the specified Size
+is at least as large as its subtype's Size, and corresponds to a size in
+storage elements that is a multiple of the object's Alignment (if the Alignment
+is nonzero).>
+
+
+!corrigendum 13.3(50)
+
+@drepl
+If the Size of a subtype is specified, and allows for efficient independent
+addressability (see 9.10) on the target architecture, then the Size of the
+following objects of the subtype should equal the Size of the subtype:
+@dby
+If the Size of a subtype allows for efficient independent
+addressability (see 9.10) on the target architecture, then the Size of the
+following objects of the subtype should equal the Size of the subtype:
+
+!corrigendum 13.3(56)
+
+@dinsa
+@xbullet<For a subtype implemented with levels of indirection, the Size should
+include the size of the pointers, but not the size of what they point at.>
+@dinss
+@xbullet<An implementation need not support a Size clause for a signed integer
+type specifying a Size greater than the largest Size value that would be chosen
+by default (i.e. in the absence of a Size clause) for any signed integer type.
+Corresponding advice applies for modular integer types, fixed point types, and
+enumeration types.>
+
+@xbullet<For floating point types, access types, record types, array types,
+protected types, and task types, an implementation need not support a
+nonconfirming Size clause.>
+
+
+!ACATS Test
+
+There are existing "Recommended Level of Support" tests which cover most of
+this advice. It probably would be worth checking for missing coverage.
 
 !appendix