CVS difference for ai12s/ai12-0043-1.txt

Differences between 1.2 and version 1.3
Log of other versions for file ai12s/ai12-0043-1.txt

--- ai12s/ai12-0043-1.txt	2012/12/05 04:18:26	1.2
+++ ai12s/ai12-0043-1.txt	2013/01/03 05:35:47	1.3
@@ -1,5 +1,7 @@
-!standard 13.11(18)                                  12-11-29    AI12-0043-1/01
+!standard 13.11(18)                                  13-01-02    AI12-0043-1/02
 !class binding interpretation 12-11-29
+!status Amendment 202x 13-01-02
+!status ARG Approved 10-0-1  12-12-08
 !status work item 12-11-29
 !status received 12-07-05
 !priority Medium
@@ -8,7 +10,7 @@
 !summary
 
 The storage pool used by an access type that has Storage_Size specified
-must must not allocate additional storage when the initial amount is
+must not allocate additional storage when the initial amount is
 exhausted, and the memory must not be shared with other types unless
 that is explicitly requested by attaching the pool to another type.
 
@@ -33,14 +35,14 @@
 
 Modify 13.11(18):
 
-If Storage_Size is specified for an access type T, {an
+If Storage_Size is specified for an access type{ T}, {an
 implementation-defined pool P is used for the type. The}[then the]
 Storage_Size of [this pool]{P} is at least that requested, and the
 storage for [the pool]{P} is reclaimed when the master containing the
 declaration of the access type is left. If the implementation cannot
-satisfy the request, Storage_Error is raised at the point of the
-attribute_definition_clause {or aspect_clause}. {The storage pool P
-is used only for allocators returning type T, or other access types
+satisfy the request, Storage_Error is raised at the {freezing} point of
+{type T}[the attribute_definition_clause]. {The storage pool P
+is used only for allocators returning type T or other access types
 specified to use T'Storage_Pool. Storage_Error is raised by an allocator
 returning such a type if the storage space of P is exhausted
 (additional memory is not allocated).}
@@ -60,14 +62,47 @@
 the expected number of allocations (with reasonable rounding) work
 and then Storage_Error is raised.
 
-Finally, note that while the definition of Storage_Pools talks about
+Note that while the definition of Storage_Pools talks about
 what the operations are "intended" to do, this wording exists only because
 a user-defined pool can do anything it wants to, whether or not that makes
 any sense compared to the intent. For implementation-defined pools, it
 is expected that they follow the intent - there is no reason for them to
 deviate. We could try to add some normative wording to that effect, but it's
-hard to word and it only seems necessary to someone that is trying to cheat.
-(What else could the Standard reasonably intend??)
+hard to word and it only seems necessary to someone who is trying to cheat.
+
+We changed the point where Storage_Error is raised in this wording. That's
+necessary in case Storage_Error is specified with an aspect (likely in new
+code) -- in that case, no attribute_definition_clause is available to be
+the point of raising the error. In addition, the amount to round up might not
+be available until the type is frozen (if it depends on the designated type).
+In any case, the exception will be raised in the same declarative part,
+and it would take a truely pathological program to be able to tell the
+difference (having a declaration with a side-effect occuring between the
+attribute_definition_clause and the freezing point).
+
+!corrigendum 13.11(18)
+
+@drepl
+If Storage_Size is specified for an access type, then the Storage_Size of this
+pool is at least that requested, and the storage for the pool is reclaimed when
+the master containing the declaration of the access type is left. If the
+implementation cannot satisfy the request, Storage_Error is raised at the point
+of the @fa<attribute_definition_clause>. If neither Storage_Pool nor Storage_Size
+are specified, then the meaning of Storage_Size is implementation defined. 
+@dby
+If Storage_Size is specified for an access type @i<T>, an
+implementation-defined pool @i<P> is used for the type. The
+Storage_Size of @i<P> is at least that requested, and the
+storage for @i<P> is reclaimed when the master containing the
+declaration of the access type is left. If the implementation cannot
+satisfy the request, Storage_Error is raised at the freezing point of
+type @i<T>. The storage pool @i<P> is used only for allocators returning type @i<T>
+or other access types specified to use @i<T>'Storage_Pool. Storage_Error is raised
+by an @fa<allocator> returning such a type if the storage space of @i<P> is
+exhausted (additional memory is not allocated).
+
+If neither Storage_Pool nor Storage_Size are specified, then the meaning of
+Storage_Size is implementation defined.
 
 !ACATS test
 

Questions? Ask the ACAA Technical Agent