CVS difference for ais/ai-00224.txt

--- ais/ai-00224.txt	2003/01/15 00:06:36	1.25
+++ ais/ai-00224.txt	2003/03/04 04:56:21	1.26
@@ -1,6 +1,16 @@
-!standard 11.5(1-8)                                  03-01-14  AI95-00224/07
+!standard 11.5(1)                                    03-02-17  AI95-00224/08
+!standard 11.5(3)
+!standard 11.5(4)
+!standard 11.5(5)
+!standard 11.5(6)
+!standard 11.5(7)
+!standard 11.5(8)
 !standard 11.5(27)
+!standard 11.5(29)
+!standard J.10(00)
 !class amendment 99-11-19
+!status Amendment 200Y 03-02-17
+!status ARG Approved 8-0-0  03-02-07
 !status work item 99-11-19
 !status received 99-11-19
 !priority Medium
@@ -84,7 +94,7 @@
 a subprogram that has a pragma Inline applied to it, then the checking pragma
 also applies to the inlined subprogram body.]
 
-AARM Proof: An instance is copy of the generic at the place of the
+AARM Proof: An instance is a copy of the generic at the place of the
 instantiation (see 12.3(12)); and inlined subprogram bodies are expanded at the
 place of the call (see 6.3.2). This rule just makes it clear that we meant
 that.
@@ -98,16 +108,17 @@
 not a requirement.
 
 A pragma Suppress gives permission to an implementation to omit the named check
-for any entities to which it applies. If permission has been given to suppress
-a given check, the check is said to be suppressed.
+(or every check in the case of All_Checks) for any entities to which it applies.
+If permission has been given to suppress a given check, the check is said to be
+suppressed.
+
+A pragma Unsuppress revokes the permission to omit the named check (or every
+check in the case of All_Checks) given by any pragma Suppress that applies at the
+point of the pragma Unsuppress. The permission is revoked for the region to
+which the pragma Unsuppress applies. If there is no such permission at the
+point of a pragma Unsuppress, then the pragma has no effect. [A later pragma
+Suppress can renew the permission.]
 
-A pragma Unsuppress revokes the permission to omit the named check
-given by any pragma Suppress that applies at the the point of the
-pragma Unsuppress. The permission is revoked for the region to which
-the pragma Unsuppress applies. If there is no such permission at the point of
-a pragma Unsuppress, then the pragma has no effect. [A later Suppress pragma
-can renew the permission.]
-
 AARM Note: Unsuppress does not have an effect on the check suppression implicit
 in pragma Unchecked_Union. However, implementations should insure that it
 does apply to suppression which comes from compiler options (preferably by
@@ -394,6 +405,171 @@
 Alternative names and definitions were considered for this pragma. These were
 ultimately rejected in order to standardize current practice, and to simplify
 the presentation. Some of these are discussed in the Appendix.
+
+!corrigendum 11.5(1)
+
+@drepl
+A @fa<pragma> Suppress gives permission to an implementation to omit certain
+language-defined checks.
+@dby
+@i<Checking pragmas> give an implementation instructions on handling
+language-defined checks. A @fa<pragma> Suppress gives permission to an
+implementation to omit certain language-defined checks, while a @fa<pragma>
+Unsuppress revokes the permission to omit checks.
+
+!corrigendum 11.5(3)
+
+@drepl
+@xindent<The form of a @fa<pragma> Suppress is as follows:>
+@dby
+@xindent<The forms of checking pragmas are as follows:>
+
+!corrigendum 11.5(4)
+
+@drepl
+@xindent<@b<pragma> Suppress(@fa<identifier> [, [On =@>] @fa<name>]);>
+@dby
+@xindent<@b<pragma> Suppress(@fa<identifier>);@hr
+@b<pragma> Unsuppress(@fa<identifier>);>
+
+!corrigendum 11.5(5)
+
+@drepl
+A @fa<pragma> Suppress is allowed only immediately within a
+@fa<declarative_part>, immediately within a @fa<package_specification>, or as
+a configuration pragma.
+@dby
+A checking pragma is allowed only immediately within a @fa<declarative_part>,
+immediately within a @fa<package_specification>, or as a configuration pragma.
+
+!corrigendum 11.5(6)
+
+@drepl
+The @fa<identifier> shall be the name of a check. The @fa<name> (if present)
+shall statically denote some entity.
+@dby
+The @fa<identifier> shall be the name of a check.
+
+!corrigendum 11.5(7)
+
+@ddel
+For a @fa<pragma> Suppress that is immediately within a
+@fa<package_specification> and includes a @fa<name>, the @fa<name> shall denote
+an entity (or several overloaded subprograms) declared immediately within the
+@fa<package_specification>.
+
+!corrigendum 11.5(8)
+
+@drepl
+A @fa<pragma> Suppress gives permission to an implementation to omit the named check
+from the place of the @fa<pragma> to the end of the innermost enclosing declarative
+region, or, if the @fa<pragma> is given in a @fa<package_specification> and includes a
+@fa<name>, to the end of the scope of the named entity. If the @fa<pragma> includes a
+@fa<name>, the permission applies only to checks performed on the named entity, or,
+for a subtype, on objects and values of its type. Otherwise, the permission
+applies to all entities. If permission has been given to suppress a given
+check, the check is said to be @i<suppressed>.
+@dby
+A checking pragma applies to the named check in a specific region (see below),
+and applies to all entities in that region. A checking pragma given in a
+@fa<declarative_part> or immediately within a @fa<package_specification>
+applies from the place of the @fa<pragma> to the end of the innermost enclosing
+declarative region. The region for a checking pragma given as a configuration
+pragma is the declarative region for the entire compilation unit to which it
+applies.
+
+If a checking pragma applies to a generic instantiation, then the checking
+pragma also applies to the instance. If a checking pragma applies to a call to
+a subprogram that has a pragma Inline applied to it, then the checking pragma
+also applies to the inlined subprogram body.
+
+A @fa<pragma> Suppress gives permission to an implementation to omit the named
+check (or every check in the case of All_Checks) for any entities to which it
+applies. If permission has been given to suppress a given check, the check is
+said to be @i<suppressed>.
+
+A @fa<pragma> Unsuppress revokes the permission to omit the named check (or
+every check in the case of All_Checks) given by any @fa<pragma> Suppress that
+applies at the point of the @fa<pragma> Unsuppress. The permission is revoked
+for the region to which the @fa<pragma> Unsuppress applies. If there is no such
+permission at the point of a @fa<pragma> Unsuppress, then the pragma has no
+effect. A later @fa<pragma> Suppress can renew the permission.
+
+!corrigendum 11.5(27)
+
+@drepl
+An implementation is allowed to place restrictions on Suppress @fa<pragma>s. An
+implementation is allowed to add additional check names, with
+implementation-defined semantics. When Overflow_Check has been suppressed, an
+implementation may also suppress an unspecified subset of the Range_Checks.
+@dby
+An implementation is allowed to place restrictions on checking pragmas,
+subject only to the requirement that @fa<pragma> Unsuppress shall allow any
+check names supported by @fa<pragma> Suppress. An implementation is allowed to
+add additional check names, with implementation-defined semantics. When
+Overflow_Check has been suppressed, an implementation may also suppress
+an unspecified subset of the Range_Checks.
+
+An implementation may support an additional parameter on @fa<pragma> Unsuppress
+similar to the one allowed for pragma Suppress (see J.10). The meaning of
+such a parameter is implementation-defined.
+
+!corrigendum 11.5(29)
+
+@dinsa
+2 There is no guarantee that a suppressed check is actually removed; hence a
+@fa<pragma> Suppress should be used only for efficiency reasons.
+@dinst
+3 It is possible to give both a @fa<pragma> Suppress and Unsuppress for the same
+check immediately within the same @fa<declarative_part>. In that case, the last
+@fa<pragma> given determines whether or not the check is suppressed. Similarly,
+it is possible to resuppress a check which has been unsuppressed by giving a
+pragma Suppress in an inner declarative region.
+
+!corrigendum J.10(01)
+
+@dinsc
+@fa<Pragma> Suppress can be used to suppress checks on specific entities.
+
+@i<@s8<Syntax>>
+
+The form of a specific Suppress @fa<pragma> is as follows:
+
+@xindent<@b<pragma> Suppress(@fa<identifier>, [On =@>] @fa<name>);>
+
+@i<@s8<Legality Rules>>
+
+The @fa<identifier> shall be the name of a check (see 11.5). The @fa<name> shall
+statically denote some entity.
+
+For a specific Suppress @fa<pragma> that is immediately within a
+@fa<package_specification>, the @fa<name> shall denote an entity (or several
+overloaded subprograms) declared immediately within the
+@fa<package_specification>.
+
+@i<@s8<Static Semantics>>
+
+A specific Suppress @fa<pragma> applies to the named check from the place of the
+@fa<pragma> to the end of the innermost enclosing declarative region, or, if the
+@fa<pragma> is given in a @fa<package_specification>, to the end of the scope
+of the named entity. The @fa<pragma> applies only to the named entity, or, for a
+subtype, on objects and values of its type. A specific Suppress @fa<pragma>
+suppresses the named check for any entities to which it applies (see 11.5).
+Which checks are associated with a specific entity is not defined by this
+standard.
+
+@i<@s8<Implementation Permissions>>
+
+An implementation is allowed to place restrictions on specific Suppress @fa<pragma>s.
+
+@xindent<@s9<NOTES@hr
+3 An implementation may support an entity parameter on @fa<pragma> Unsuppress (see
+11.5).>>
+
+!ACATS Tests
+
+ACATS C-tests should be created to check that checks are performed in a nested
+scope containing Unsuppress. (Most of this is not testable, unfortunately.)
 
 !appendix