CVS difference for ais/ai-00051.txt

Differences between 1.9 and version 1.10
Log of other versions for file ais/ai-00051.txt

--- ais/ai-00051.txt	2004/11/25 00:03:21	1.9
+++ ais/ai-00051.txt	2004/12/09 18:01:06	1.10
@@ -1,4 +1,4 @@
-!standard 13.03    (25)                               04-11-08  AI95-00051/14
+!standard 13.03    (25)                             04-12-08  AI95-00051-01/15
 !standard 13.03    (28)
 !standard 13.03    (30)
 !standard 13.03    (31)
@@ -9,7 +9,6 @@
 !standard 13.03    (56)
 !class binding interpretation 95-06-25
 !status Amendment 200Y 04-09-27
-!status WG9 approved 04-11-18
 !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
@@ -39,19 +38,30 @@
    implementation would have chosen by default (that is, a "confirming"
    representation item, as defined in AI-291).
 
-2. For a signed integer type, the implementation need not support a
-   Size/Alignment clause which specifies a value larger than the largest
-   Size/Alignment value that would be chosen by the implementation
-   in the absence of a attribute_definition_clause for any signed integer
-   type. Corresponding advice applies for modular integer types,
-   fixed point types, enumeration types, record types, and array types.
+2. For a signed integer type, the implementation should support an
+   Alignment clause which specifies a value no larger than the largest
+   Alignment value that would be chosen by the implementation in the absence
+   of an attribute_definition_clause for any signed integer type. Corresponding
+   advice applies for modular integer types, fixed point types, enumeration
+   types, record types, and array types.
+
+3. For a signed integer type, the implementation should support a
+   Size clause which specifies a value no larger than the largest
+   Size value that would be chosen by the implementation in the absence of
+   an attribute_definition_clause for any signed integer type. Corresponding
+   advice applies for modular integer types, fixed point types, and enumeration
+   types.
 
-3. Only confirming Size/Alignment clauses need be supported for floating point
+4. Only confirming Alignment clauses need be supported for floating point
    types, access types, protected types, and task types.
 
-4. Alignments other than a power-of-two need not be supported.
+5. Only confirming Size clauses need be supported for floating point
+   types, access types, record types, arrays types, protected types, and task
+   types.
 
-5. Confirming representation items have no semantic effect (this means
+6. Alignments other than a power-of-two need not be supported.
+
+7. Confirming representation items have no semantic effect (this means
    eliminating rules of the form "If attribute Xyz is specified, then" ...)
 
 !question
@@ -86,19 +96,20 @@
 
 Replace 13.3(30-32) with:
 
-    - An implementation need not support a nonconfirming Alignment clause
-      specifying an Alignment which is neither zero nor a power
-      of two.
+    - An implementation should support a confirming Alignment clause for
+      any kind of type.
 
-    - 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.
+    - An implementation should support a nonconfirming Alignment clause
+      for a discrete type, fixed point type, record type, or
+      array type, specifying an Alignment value that is zero or
+      a power of two, subject to the following:
 
-    - For floating point types, access types, protected types, and task types,
-      an implementation need not support a nonconfirming Alignment clause.
+    - An implementation need not support an Alignment clause for a signed
+      integer type specifying an Alignment greater than the largest
+      Alignment value that is ever chosen by default by the implementation
+      for any signed integer type. A corresponding limitation may be
+      imposed for modular integer types, fixed point types, enumeration types,
+      record types, and array types.
 
     - An implementation need not support a nonconfirming Alignment clause
       which could enable the creation of an object of an elementary type
@@ -117,16 +128,18 @@
 
 Insert after 13.3(56) (as part of the bulleted list)
 
+    - An implementation should support a confirming Size clause for any
+      kind of type.
+
+    - An implementation should support a nonconfirming Size clause for
+      a discrete type or a fixed point type, subject to the following:
+
     - 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 (that is, 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.
-
-    - For floating point types, access types, array types, record types,
-      protected types, and task types, an implementation need not support a
-      nonconfirming Size clause.
+      integer type specifying a Size greater than that of the largest
+      signed integer type supported by the implementation
+      in the absence of a size clause (that is, when the size is
+      chosen by default). A corresponding limitation may be imposed for
+      modular integer types, fixed point types, and enumeration types.
 
 !discussion
 
@@ -136,6 +149,9 @@
 This AI depends on AI-291's definition of "confirming", as well as AI-291's
 coverage of various cases involving aliased objects and by-reference types.
 
+We "recommend" support for nonconfirming Size and Alignment clauses
+for a discrete and fixed-point type.
+
 !example
 
 This example shows some ramifications of the Recommended Level of Support.
@@ -196,8 +212,13 @@
 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.>
+@xbullet<An implementation should support a confirming Alignment clause for
+any kind of type.>
+
+@xbullet<An implementation should support a nonconfirming Alignment clause
+for a discrete type, fixed point type, record type, or
+array type, specifying an Alignment value that is zero or
+a power of two, subject to the following:>
 
 !corrigendum 13.3(31)
 
@@ -207,14 +228,12 @@
 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.>
+integer type specifying an Alignment greater than the largest
+Alignment value that is ever chosen by default by the implementation
+for any signed integer type. A corresponding limitation may be
+imposed 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
@@ -222,8 +241,9 @@
 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 object of an elementary type which cannot
-be easily loaded and stored by available machine instructions.>
+which could enable the creation of an object of an elementary type
+which cannot be easily loaded and stored by available machine instructions.>
+
 
 !corrigendum 13.3(42)
 
@@ -259,16 +279,18 @@
 @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 (that is, 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.>
+@xbullet<An implementation should support a confirming Size clause for any
+kind of type.>
+
+@xbullet<An implementation should support a nonconfirming Size clause for
+a discrete type or a fixed point type, subject to the following:>
 
+@xbullet<An implementation need not support a Size clause for a signed
+integer type specifying a Size greater than that of the largest
+signed integer type supported by the implementation
+in the absence of a size clause (that is, when the size is
+chosen by default). A corresponding limitation may be imposed for
+modular integer types, fixed point types, and enumeration types.>
 
 !ACATS Test
 

Questions? Ask the ACAA Technical Agent