Version 1.2 of ai05s/ai05-0264-1.txt

Unformatted version of ai05s/ai05-0264-1.txt version 1.2
Other versions for file ai05s/ai05-0264-1.txt

!standard 3.3(23)          11-08-14 AI05-0264-1/02
!standard 4.5.2(28)
!standard 4.5.7(0)
!standard 6.7(3/2)
!standard 6.8(0)
!standard 13.3(73)
!standard 13.13.2(9/2)
!standard 13.13.2(56/2)
!standard A.10.7(8/1)
!standard A.16(82/2)
!standard A.18.2(115/2)
!standard A.18.10(0)
!standard A.18.19(0)
!standard A.18.20(0)
!standard A.18.21(0)
!standard A.18.22(0)
!standard A.18.23(0)
!standard A.18.24(0)
!standard A.18.25(0)
!standard A.18.27(0)
!standard D.2.4(2/2)
!standard D.14.3(0)
!standard D.15(15/2)
!standard D.16(0)
!class presentation 11-08-10
!status Amendment 2012 11-08-10
!status work item 11-08-10
!status received 11-04-17
!priority Low
!difficulty Easy
!subject Add missing commas and other editorial changes in the standard
!summary
Make various editorial changes in the Standard, mostly adding missing commas.
!question
There are number of places in the Standard where commas and other punctuation are used incorrectly. Should these be fixed? (Yes.)
!recommendation
(See Summary.)
!wording
[Note: /3 paragraph numbers are from draft 13.]
Instances of "otherwise" that should be followed by a comma: ------------------------------------------------------------
3.3(23) "otherwise{,} the subtype ..."
3.3.1(6) "Otherwise{,} it is called ..."
3.5(30/2) "otherwise{,} the sequence of ..."
3.5(37/2) "otherwise{,} the sequence of ..."
3.5(39.4/2) "otherwise{,} Constraint_Error ..."
3.5(39.5/2) "otherwise{,} Constraint_Error ..."
3.5(39.12/2) "otherwise{,} Constraint_Error ..."
3.5(43/2) "otherwise{,} Constraint_Error ..."
3.5(55/2) "otherwise{,} Constraint_Error ..."
3.10(12/2) "otherwise{,} it is an access-to-variable type."
3.10(14/1) "otherwise{,} it is constrained."
4.5.2(26) "otherwise{,} the left operand ..."
4.5.2(28.1/3) "otherwise{,} the test uses ..."
4.5.2(31) "Otherwise{,} the test yields ..."
4.5.7(10/3) "; otherwise{,}"
4.5.7(11/3) "; otherwise{,}"
4.5.7(12/3) "; otherwise{,}"
4.6(26) "otherwise{,} it is a constant ..."
5.3(5) "otherwise{,} none of them is executed."
6.3.1(13.1/2) "and{,} otherwise{,} is the convention ..."
6.5(8/3) "if it is specific, or{,} otherwise{,} that of the value ..."
9.5.3(6) "otherwise{,} it is closed."
9.5.3(7) "otherwise{,} it is closed."
9.8(20) "otherwise{,} the operations proceed ..."
10.1.4(4/1) "otherwise{,} the subprogram_body ..."
12.5.1(23) "otherwise{,} it yields False."
13.13.2(9.2/2) "otherwise{,} the range is signed."
A.4.2(32) "otherwise{,} the returned value ..."
A.4.2(36) "otherwise{,} the shortest array ..."
A.4.3(58.2/2) "otherwise{,} returns"
A.4.3(60.2/2) "otherwise{,} returns"
A.4.3(78) "otherwise{,} returns ..."
A.4.3(82) "otherwise{,} returns ..."
A.4.3(86/1) "otherwise{,} it is source ..."
A.4.3(98) "Otherwise{,} its contents ..."
A.4.3(102) "Otherwise{,} its contents ..."
A.4.3(107) "Otherwise{,} the pattern ..."
A.4.4(87) "Otherwise{,} the effect ..."
A.8.2(28) "[,]{;} otherwise{,} returns False."
A.8.3(9) "otherwise{,} returns False."
A.8.5(15) "otherwise{,} returns False."
A.10.5(13) "otherwise{,} returns False."
A.10.5(22) "otherwise{,} returns False."
A.10.5(25) "otherwise{,} returns False."
A.10.7(8/3) "Otherwise{,} End_Of_Line is ..."
A.12.1(28.3/2) "otherwise{,} it returns False."
A.12.1(28.4/2) "otherwise{,} it returns False."
A.15(12) "Otherwise{,} it returns 0."
A.15(16) "otherwise{,} Command_Name returns ..."
A.16(82/2) "Otherwise{,} Name is ..."
A.17(13/2) "otherwise{,} it returns False."
A.17(15/2) "Otherwise{,} Program_Error ..."
A.17(19/2) "Otherwise{,} Program_Error ..."
A.17(21/2) "Otherwise{,} Program_Error ..."
A.17(23/2) "Otherwise{,} Program_Error ..."
A.18.1(135/2) "Otherwise{,} Replace_Element ..."
A.18.2(99/2) "otherwise{,} it returns True."
A.18.2(119/2) "otherwise{,} elements are removed ..."
A.18.2(133/2) "Otherwise{,} Replace_Element ..."
A.18.2(135/2) "Otherwise{,} Replace_Element ..."
A.18.2(145/2) "Otherwise{,} Replace_Element ..."
A.18.2(154/2) "otherwise{,} The call is ..."
A.18.2(182/2) "Otherwise{,} Delete ..."
A.18.2(188/2) "Otherwise{,} it is equivalent ..."
A.18.2(218/2) "Otherwise{,} Find ..."
A.18.2(222/2) "Otherwise{,} Reverse_Find ..."
A.18.3(71/2) "otherwise{,} it returns True."
A.18.3(81/2) "Otherwise{,} Replace_Element ..."
A.18.3(85/2) "Otherwise{,} Update_Element ..."
A.18.3(100/2) "Otherwise{,} Delete ..."
A.18.3(104/2) "Otherwise{,} it removes ..."
A.18.3(114/2) "Otherwise{,} the element ..."
A.18.3(118/2) "Otherwise{,} it returns ..."
A.18.3(122/2) "Otherwise{,} it returns ..."
A.18.4(36/2) "Otherwise{,} Replace_Element ..."
A.18.4(40/2) "Otherwise{,} Update_Element ..."
A.18.6(60/2) "Otherwise{,} the node ..."
A.18.6(74/2) "Otherwise{,} Previous ..."
A.18.6(78/2) "Otherwise{,} No_Element ..."
A.18.6(80/2) "Otherwise{,} No_Element ..."
A.18.7(70/2) "Otherwise{,} it returns False."
A.18.7(72/2) "Otherwise{,} it returns True."
A.18.9(83/2) "Otherwise{,} the element ..."
A.18.9(85/2) "Otherwise{,} the element ..."
A.18.9(93/2) "Otherwise{,} Previous ..."
A.18.9(97/2) "Otherwise{,} No_Element ..."
A.18.9(99/2) "Otherwise{,} No_Element ..."
A.18.10(82/3) "otherwise{,} it returns True ..."
A.18.10(92/3) "otherwise{,} Depth ..."
A.18.10(104/3) "Otherwise{,} Replace_Element ..."
A.18.10(108/3) "Otherwise{,} Update_Element ..."
A.18.10(117/3) "Otherwise{,} Delete_Leaf ..."
A.18.10(119/3) "Otherwise{,} Delete ..."
A.18.10(167/3) "Otherwise{,} the child elements ..."
A.18.21(14/3) "otherwise{,} the map modulus ..."
A.18.23(14/3) "otherwise{,} the set modulus ..."
A.18.27(10/3) "otherwise{,} Enqueue ..."
B.3.1(24/1) "otherwise{,} To_Chars_Ptr ..."
B.3.1(34/1) "Otherwise{,} Value ..."
B.3.1(36/1) "Otherwise{,} Value ..."
C.7.3(10/2) "[,]{;} otherwise{,} it is set ..."
C.7.3(11/2) "otherwise{,} it returns null."
C.7.3(12/2) "[,]{;} otherwise{,} it is set to ..."
C.7.3(13/2) "otherwise{,} it returns null ..."
D.2.5(8/2) "otherwise{,} it returns False."
D.14.1(15/2) "[,]{;} otherwise{,} it is set."
D.14.1(18/2) "otherwise{,} it returns null."
D.14.1(19/2) "otherwise{,} it is assigned False."
D.14.1(20/2) "otherwise{,} it returns Time_Span_Zero."
D.14.2(18/2) "otherwise{,} it return{s} False."
^^^ note additional typo
D.14.2(19/2) "otherwise{,} it returns False."
D.14.2(23/2) "otherwise{,} it returns False."
D.14.2(25/2) "[,]{;} otherwise{,} it is set."
D.14.2(27/2) "otherwise{,} it returns null."
D.14.2(28/2) "otherwise{,} it is assigned False."
D.14.3(7/3) "Otherwise{,} it returns False."
D.15(11/2) "[,]{;} otherwise{,} it is set."
D.15(16/2) "otherwise{,} it returns null."
D.15(17/2) "otherwise{,} it is assigned False."
D.15(18/2) "otherwise{,} it returns ..."
F.3.3(44) "Otherwise{,} unassigned ..."
K(51) "otherwise{,} it yields False."
K(83.4/3) "it is [f]{F}alse otherwise."
K(172.4/3) "it is [f]{F}alse otherwise."
One instance of "however" that should be followed by a comma: -------------------------------------------------------------
6.8(6/3) "[,]{;} however{,} an expression_function_declaration ..."
[Editor's note: There is a similar case in 6.7(3/3), there are two commas, changed the first to a semicolon.]
Instances of "then" that should be preceded by a comma: -------------------------------------------------------
3.2.3(26) "constrained{,} then"
3.8(12) "derived_type_definition{,} then"
3.8.1(16) "scalar type{,} then"
13.5.1(13.2/2) "applies to the type{,} then"
13.13.2(9.1/3) "have defaults{,} then"
13.13.2(56.1/3) "have defaults{,} then"
A.4.2(36) "If Set = Null_Set{,} then"
A.4.3(45) "If Source is shorter than Target{,} then"
A.4.4(87) "If Source'Length <= Max_Length{,} then"
A.18.2(115/3) "equal to Capacity{,} then"
A.18.2(151/2) "greater than Index_Type'Last{,} then"
A.18.2(164/2) "greater than Index_Type'Last{,} then"
A.18.2(177/2) "greater than Index_Type'Last{,} then"
A.18.2(188/2) "If Length (Container) <= Count{,} then"
A.18.3(104/2) "If Length (Container) <= Count{,} then"
A.18.3(114/2) "If Position is No_Element{,} then"
A.18.3(116/2) "If Position is No_Element{,} then"
A.18.10(141/3) "If Parent already has child nodes{,} then"
A.18.10(143/3) "If Parent already has child nodes{,} then"
A.18.10(145/3) "If Parent already has child nodes{,} then"
A.18.10(153/3) "If Parent already has child nodes{,} then"
A.18.10(155/3) "If Parent already has child nodes{,} then"
A.18.10(156/3) "If Parent already has child nodes{,} then"
A.18.10(158/3) "If Parent already has child nodes{,} then"
A.18.10(164/3) "If Target_Parent already has child nodes{,} then"
A.18.10(165/3) "If Target_Parent already has child nodes{,} then"
A.18.10(167/3) "If Target_Parent already has child nodes{,} then"
A.18.19(11/3) "following conditions{,} then"
A.18.20(15/3) "following conditions{,} then"
A.18.21(16/3) "following conditions{,} then"
A.18.22(13/3) "following conditions{,} then"
A.18.23(16/3) "following conditions{,} then"
A.18.24(13/3) "following conditions{,} then"
A.18.25(15/3) "following conditions{,} then"
B.3(60.15/1) "If a type is C_Pass_By_Copy-compatible{,} then"
B.3.1(34) "If Item = Null_Ptr{,} then"
B.3.1(36/1) "If Item = Null_Ptr{,} then"
B.4(63/1) "digit characters{,} then"
D.2.4(2.3/3) "than the calling task{,} then"
D.2.6(13/2) "If there is no Relative_Deadline pragma{,} then"
D.2.6(33/2) "policy EDF_Across_Priorities{,} then"
D.5.2(5/2) "is in effect{,} then"
D.14.1(28/2) "If this limit is exceeded{,} then"
D.14.2(32/2) "when it terminates{,} then"
D.15(15/3) "in the past{,} then"
D.16(15/3) "is Not_A_Specific_CPU{,} then"
G.2.3(14) "otherwise, if truncation applies{,} then"
"whereas if rounding applies{,} then"
G.3(88/2) "if this is done{,} then"
G.3.2(158/2) "if this is done{,} then"
H.6(6/2) "for a partition{,} then"
H.6(15/2) "during elaboration{,} then"
H.6(16/2) "task activation fails{,} then"
M.3(130/2) "during elaboration{,} then"
Uncapitalized "False": ----------------------
11.5(2) "when the condition being checked is [false]{False}, ..."
13.3(73.4/3) "it is [false]{False} otherwise."
Actually, for consistency with similar rules, it would be better to move the "otherwise" to the beginning: "otherwise, it is False".
13.3(73.8/3) "it is [false]{False} otherwise."
Same comment as for 13.3(73.4/3).
K(83.4/3) "it is [false]{False} otherwise."
Same comment as for 13.3(73.4/3).
K(172.4/3) "it is [false]{False} otherwise."
Same comment as for 13.3(73.4/3).
Uncapitalized "True": ---------------------
4.5.2(38) Three instances of "true" in example comments that should "True".
13.3(73.4/3) "and returns [true]{True} if"
13.3(73.8/3) "and returns [true]{True} if"
K(83.4/3) "and returns [true]{True} if"
K(172.4/3) "and returns [true]{True} if"
M.3(119/2) "If Real'Signed_Zeros is [true]{True}"
M.3(120/2) "If Complex_Types.Real'Signed_Zeros is [true]{True}"
!discussion
We only have !standard and !corrigendum references for paragraphs that are changed by other AIs. Otherwise, we are treating these as normal editorial changes.
!corrigendum 4.5.2(28)
Replace the paragraph:
A membership test using in yields the result True if:
by:
An individual membership test yields the result True if:
!corrigendum 4.5.7(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum 6.7(3/2)
Replace the paragraph:
A null_procedure_declaration declares a null procedure. A completion is not allowed for a null_procedure_declaration.
by:
A null_procedure_declaration declares a null procedure. A completion is not allowed for a null_procedure_declaration; however a null_procedure_declaration can complete a previous declaration.
!corrigendum 6.8(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum 13.03(73)
Insert after the paragraph:
the new paragraphs:
(See conflict file for actual wording.)
!corrigendum 13.13.2(9/2)
Replace the paragraph:
For elementary types, Read reads (and Write writes) the number of stream elements implied by the Stream_Size for the type T; the representation of those stream elements is implementation defined. For composite types, the Write or Read attribute for each component is called in canonical order, which is last dimension varying fastest for an array, and positional aggregate order for a record. Bounds are not included in the stream if T is an array type. If T is a discriminated type, discriminants are included only if they have defaults. If T is a tagged type, the tag is not included. For type extensions, the Write or Read attribute for the parent type is called, followed by the Write or Read attribute of each component of the extension part, in canonical order. For a limited type extension, if the attribute of the parent type or any progenitor type of T is available anywhere within the immediate scope of T, and the attribute of the parent type or the type of any of the extension components is not available at the freezing point of T, then the attribute of T shall be directly specified.
by:
For elementary types, Read reads (and Write writes) the number of stream elements implied by the Stream_Size for the type T; the representation of those stream elements is implementation defined. For composite types, the Write or Read attribute for each component is called in canonical order, which is last dimension varying fastest for an array (unless the convention of the array is Fortran, in which case it is first dimension varying fastest), and positional aggregate order for a record. Bounds are not included in the stream if T is an array type. If T is a discriminated type, discriminants are included only if they have defaults. If T is a tagged type, the tag is not included. For type extensions, the Write or Read attribute for the parent type is called, followed by the Write or Read attribute of each component of the extension part, in canonical order. For a limited type extension, if the attribute of the parent type or any progenitor type of T is available anywhere within the immediate scope of T, and the attribute of the parent type or the type of any of the extension components is not available at the freezing point of T, then the attribute of T shall be directly specified.
If T is a discriminated type and its discriminants have defaults, then S'Read first reads the discriminants from the stream without modifying Item. S'Read then creates an object of type T constrained by these discriminants. The value of this object is then converted to the subtype of Item and is assigned to Item. Finally, the Read attribute for each non-discriminant component of Item is called in canonical order as described above. Normal default initialization and finalization take place for the created object.
!corrigendum 13.13.2(56/2)
Replace the paragraph:
The number of calls performed by the predefined implementation of the stream-oriented attributes on the Read and Write operations of the stream type is unspecified. An implementation may take advantage of this permission to perform internal buffering. However, all the calls on the Read and Write operations of the stream type needed to implement an explicit invocation of a stream-oriented attribute must take place before this invocation returns. An explicit invocation is one appearing explicitly in the program text, possibly through a generic instantiation (see 12.3).
by:
The number of calls performed by the predefined implementation of the stream-oriented attributes on the Read and Write operations of the stream type is unspecified. An implementation may take advantage of this permission to perform internal buffering. However, all the calls on the Read and Write operations of the stream type needed to implement an explicit invocation of a stream-oriented attribute shall take place before this invocation returns. An explicit invocation is one appearing explicitly in the program text, possibly through a generic instantiation (see 12.3).
If T is a discriminated type and its discriminants have defaults, then in two cases an execution of the default implementation of S'Read is not required to create an anonymous object of type T: If the discriminants values that are read in are equal to the corresponding discriminant values of Item, then no object of type T need be created and Item may be used instead. If they are not equal and Item is a constrained variable, then Constraint_Error may be raised at that point, before any further values are read from the stream and before the object of type T is created. A default implementation of S'Input that calls the default implementation of S'Read may create a constrained anonymous object with discriminants that match those in the stream.
!corrigendum A.10.7(8/1)
Replace the paragraph:
Mode_Error is propagated if the mode of the file is not In_File. Sets End_Of_Line to True if at end of line, including if at end of page or at end of file; in each of these cases the value of Item is not specified. Otherwise End_Of_Line is set to False and Item is set to the the next character (without consuming it) from the file.
by:
Status_Error is propagated if the file is not open. Mode_Error is propagated if the mode of the file is not In_File. Sets End_Of_Line to True if at end of line, including if at end of page or at end of file; in each of these cases the value of Item is not specified. Otherwise, End_Of_Line is set to False and Item is set to the the next character (without consuming it) from the file.
!corrigendum A.16(82/2)
Replace the paragraph:
Returns the name of the external file with the specified Containing_Directory, Name, and Extension. If Extension is the null string, then Name is interpreted as a simple name; otherwise Name is interpreted as a base name. The exception Name_Error is propagated if the string given as Containing_Directory is not null and does not allow the identification of a directory, or if the string given as Extension is not null and is not a possible extension, or if the string given as Name is not a possible simple name (if Extension is null) or base name (if Extension is non-null).
by:
Returns the name of the external file with the specified Containing_Directory, Name, and Extension. If Extension is the null string, then Name is interpreted as a simple name; otherwise, Name is interpreted as a base name. The exception Name_Error is propagated if the string given as Containing_Directory is not null and does not allow the identification of a directory, or if the string given as Extension is not null and is not a possible extension, or if the string given as Name is not a possible simple name (if Extension is null) or base name (if Extension is non-null).
!corrigendum A.18.2(115/2)
Replace the paragraph:
Reserve_Capacity allocates new internal data structures such that the length of the resulting vector can become at least the value Capacity without requiring an additional call to Reserve_Capacity, and is large enough to hold the current length of Container. Reserve_Capacity then copies the elements into the new data structures and deallocates the old data structures. Any exception raised during allocation is propagated and Container is not modified.
by:
If the capacity of Container is already greater than or equal to Capacity, then Reserve_Capacity has no effect. Otherwise, Reserve_Capacity allocates additional storage as necessary to ensure that the length of the resulting vector can become at least the value Capacity without requiring an additional call to Reserve_Capacity, and is large enough to hold the current length of Container. Reserve_Capacity then, as necessary, moves elements into the new storage and deallocates any storage no longer needed. Any exception raised during allocation is propagated and Container is not modified.
!corrigendum A.18.10(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.19(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.20(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.21(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.22(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.23(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.24(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.25(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum A.18.27(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum D.2.4(2/2)
Insert after the paragraph:
The policy_identifier Non_Preemptive_FIFO_Within_Priorities is a task dispatching policy.
the new paragraphs:
The following language-defined library package exists:
package Ada.Dispatching.Non_Preemptive is pragma Preelaborate(Non_Preemptive); procedure Yield_To_Higher; procedure Yield_To_Same_Or_Higher renames Yield; end Ada.Dispatching.Non_Preemptive;
A call of Yield_To_Higher is a task dispatching point for this policy. If the task at the head of the highest priority ready queue has a higher active priority than the calling task, then the calling task is preempted.
!corrigendum D.14.3(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!corrigendum D.15(15/2)
Replace the paragraph:
If a procedure Set_Handler is called with zero or negative In_Time or with At_Time indicating a time in the past then the handler is executed immediately by the task executing the call of Set_Handler. The timing event Event is cleared.
by:
If a procedure Set_Handler is called with zero or negative In_Time or with At_Time indicating a time in the past, then the handler is executed as soon as possible after the completion of the call of Set_Handler.
!corrigendum D.16(0)
Insert new clause:
[A placeholder to cause a conflict; the real wording is found in the conflict file.]
!ACATS Test
None needed.
!ASIS
No change needed.
!appendix

From: Gary Dismukes
Sent: Sunday, April 17, 2011  12:23 AM

> Gary Dismukes:
> Study standard for missing commas (such as after Otherwise{,}) that 
> need to be added and cannot be construed to change the meaning. 
> Provide Randy with a list of clause/paragraph numbers needing such 
> changes (these will be made with minimum fuss, in particular we will 
> not include these in the Amendment document).

Here's a list of missing commas in the new RM, which I was asked to put together
as homework from the last phone meeting.

This isn't claimed to be complete of course, but is just an attempt to identify common
cases such as following 'otherwise' and 'however', and preceding 'then', in order
to make the RM more consistent.

I've also noted a small number of other corrections that I happened to notice along the way.


Instances of "otherwise" that should be followed by a comma:
------------------------------------------------------------

3.3(23)  "otherwise{,} the subtype ..."

3.3.1(6)  "Otherwise{,} it is called ..."

3.5(30/2) "otherwise{,} the sequence of ..."

3.5(37/2) "otherwise{,} the sequence of ..."

3.5(39.4/2) "otherwise{,} Constraint_Error ..."

3.5(39.5/2) "otherwise{,} Constraint_Error ..."

3.5(39.12/2) "otherwise{,} Constraint_Error ..."

3.5(43/2) "otherwise{,} Constraint_Error ..."

3.5(55/2) "otherwise{,} Constraint_Error ..."

3.10(12/2) "otherwise{,} it is an access-to-variable type."

3.10(14/1) "otherwise{,} it is constrained."


4.5.2(26)  "otherwise{,} the left operand ..."

4.5.2(28.1/3)  "otherwise{,} the test uses ..."

4.5.2(31)  "Otherwise{,} the test yields ..."

4.5.7(10/3) "; otherwise{,}"

4.5.7(11/3) "; otherwise{,}"

4.5.7(12/3) "; otherwise{,}"

4.6(26)    "otherwise{,} it is a constant ..."


5.3(5)     "otherwise{,} none of them is executed."


6.3.1(13.1/2) "and{,} otherwise{,} is the convention ..."

6.5(8/3)   "if it is specific, or{,} otherwise{,} that of the value ..."


9.5.3(6)   "otherwise{,} it is closed."

9.5.3(7)   "otherwise{,} it is closed."

9.8(20)    "otherwise{,} the operations proceed ..."


10.1.4(4/1) "otherwise{,} the subprogram_body ..."


12.5.1(23)  "otherwise{,} it yields False."


13.3.1(8/3) "otherwise{,} the prefix ..."

13.13.2(9.2/2) "otherwise{,} the range is signed."


A.4.2(32)   "otherwise{,} the returned value ..."

A.4.2(36)   "otherwise{,} the shortest array ..."

A.4.3(58.2/2) "otherwise{,} returns"

A.4.3(60.2/2) "otherwise{,} returns"

A.4.3(78) "otherwise{,} returns ..."

A.4.3(82) "otherwise{,} returns ..."

A.4.3(86/1) "otherwise{,} it is source ..."

A.4.3(98) "Otherwise{,} its contents ..."

A.4.3(102) "Otherwise{,} its contents ..."

A.4.3(107) "Otherwise{,} the pattern ..."

A.4.4(87) "Otherwise{,} the effect ..."

A.8.2(28) "[,]{;} otherwise{,} returns False."

A.8.3(9) "otherwise{,} returns False."

A.8.5(15) "otherwise{,} returns False."

A.10.5(13) "otherwise{,} returns False."

A.10.5(22) "otherwise{,} returns False."

A.10.5(25) "otherwise{,} returns False."

A.10.7(8/3) "Otherwise{,} End_Of_Line is ..."

A.12.1(28.3/2) "otherwise{,} it returns False."

A.12.1(28.4/2) "otherwise{,} it returns False."

A.15(12) "Otherwise{,} it returns 0."

A.15(16) "otherwise{,} Command_Name returns ..."

A.16(81/2) "Otherwise{,} Name is ..."

A.17(13/2) "otherwise{,} it returns False."

A.17(15/2) "Otherwise{,} Program_Error ..."

A.17(19/2) "Otherwise{,} Program_Error ..."

A.17(21/2) "Otherwise{,} Program_Error ..."

A.17(23/2) "Otherwise{,} Program_Error ..."

A.18.1(135/2) "Otherwise{,} Replace_Element ..."

A.18.2(99/2) "otherwise{,} it returns True."

A.18.2(119/2) "otherwise{,} elements are removed ..."

A.18.2(133/2) "Otherwise{,} Replace_Element ..."

A.18.2(135/2) "Otherwise{,} Replace_Element ..."

A.18.2(145/2) "Otherwise{,} Replace_Element ..."

A.18.2(154/2) "otherwise{,} The call is ..."

A.18.2(182/2) "Otherwise{,} Delete ..."

A.18.2(188/2) "Otherwise{,} it is equivalent ..."

A.18.2(218/2) "Otherwise{,} Find ..."

A.18.2(222/2) "Otherwise{,} Reverse_Find ..."

A.18.3(71/2)  "otherwise{,} it returns True."

A.18.3(81/2)  "Otherwise{,} Replace_Element ..."

A.18.3(85/2)  "Otherwise{,} Update_Element ..."

A.18.3(100/2)  "Otherwise{,} Delete ..."

A.18.3(104/2)  "Otherwise{,} it removes ..."

A.18.3(114/2)  "Otherwise{,} the element ..."

A.18.3(118/2)  "Otherwise{,} it returns ..."

A.18.3(122/2)  "Otherwise{,} it returns ..."

A.18.4(36/2)  "Otherwise{,} Replace_Element ..."

A.18.4(40/2)  "Otherwise{,} Update_Element ..."

A.18.6(60/2)  "Otherwise{,} the node ..."

A.18.6(74/2)  "Otherwise{,} Previous ..."

A.18.6(78/2)  "Otherwise{,} No_Element ..."

A.18.6(80/2)  "Otherwise{,} No_Element ..."

A.18.7(70/2)  "Otherwise{,} it returns False."

A.18.7(72/2)  "Otherwise{,} it returns True."

A.18.9(83/2)  "Otherwise{,} the element ..."

A.18.9(85/2)  "Otherwise{,} the element ..."

A.18.9(93/2)  "Otherwise{,} Previous ..."

A.18.9(97/2)  "Otherwise{,} No_Element ..."

A.18.9(99/2)  "Otherwise{,} No_Element ..."

A.18.10(82/3)  "otherwise{,} it returns True ..."

A.18.10(92/3)  "otherwise{,} Depth ..."

A.18.10(104/3)  "Otherwise{,} Replace_Element ..."

A.18.10(108/3)  "Otherwise{,} Update_Element ..."

A.18.10(117/3)  "Otherwise{,} Delete_Leaf ..."

A.18.10(119/3)  "Otherwise{,} Delete ..."

A.18.10(167/3)  "Otherwise{,} the child elements ..."

A.18.21(14/3)   "otherwise{,} the map modulus ..."

A.18.23(14/3)   "otherwise{,} the set modulus ..."

A.18.27(10/3)   "otherwise{,} Enqueue ..."


B.3.1(24/1)     "otherwise{,} To_Chars_Ptr ..."

B.3.1(34/1)     "Otherwise{,} Value ..."

B.3.1(36/1)     "Otherwise{,} Value ..."


C.7.3(10/2)     ",{;} otherwise{,} it is set ..."

C.7.3(11/2)     "otherwise{,} it returns null."

C.7.3(12/2)     ",{;} otherwise{,} it is set to ..."

C.7.3(13/2)     ",{;} otherwise{,} it returns null ..."


D.2.5(8/2)      "otherwise{,} it returns False."

D.14.1(15/2)    "[,]{;} otherwise{,} it is set."

D.14.1(18/2)    "otherwise{,} it returns null."

D.14.1(19/2)    "otherwise{,} it is assigned False."

D.14.1(20/2)    "otherwise{,} it returns Time_Span_Zero."

D.14.2(18/2)    "otherwise{,} it return{s} False."
                                       ^^^ note additional typo

D.14.2(19/2)    "otherwise{,} it returns False."

D.14.2(23/2)    "otherwise{,} it returns False."

D.14.2(25/2)    "[,]{;} otherwise{,} it is set."

D.14.2(27/2)    "otherwise{,} it returns null."

D.14.2(28/2)    "otherwise{,} it is assigned False."

D.14.3(7/3)     "Otherwise{,} it returns False."

D.15(11/2)     "[,]{;} otherwise{,} it is set."

D.15(16/2)     "otherwise{,} it returns null."

D.15(17/2)     "otherwise{,} it is assigned False."

D.15(18/2)     "otherwise{,} it returns ..."


F.3.3(44)      "Otherwise{,} unassigned ..."


K(51)          "otherwise{,} it yields False."

K(83.4/3)      "it is [f]{F}alse otherwise."

K(172.4/3)     "it is [f]{F}alse otherwise."



One instance of "however" that should be followed by a comma:
-------------------------------------------------------------

6.8    "[,]{.} [however]{However,} an expression_function_declaration ..."

[Note: alternatively, use a ';' instead of ',' before 'however'.]



Instances of "then" that should be preceded by a comma:
-------------------------------------------------------

3.2.3(26)       "constrained{,} then"

3.8(12)         "derived_type_definition{,} then"

3.8.1(16)       "scalar type{,} then"

13.5.1(13.2/2)  "applies to the type{,} then"

13.13.2(9.1/3)  "have defaults{,} then"

13.13.2(56.1/3) "have defaults{,} then"


A.4.2(36)       "If Set = Null_Set{,} then"

A.4.3(45)       "If Source is shorter than Target{,} then"

A.4.4(87)       "If Source'Length <= Max_Length{,} then"

A.18.2(115/3)   "equal to Capacity{,} then"

A.18.2(151/2)   "greater than Index_Type'Last{,} then"

A.18.2(164/2)   "greater than Index_Type'Last{,} then"

A.18.2(177/2)   "greater than Index_Type'Last{,} then"

A.18.2(188/2)   "If Length (Container) <= Count{,} then"

A.18.3(104/2)   "If Length (Container) <= Count{,} then"

A.18.3(114/2)   "If Position is No_Element{,} then"

A.18.3(116/2)   "If Position is No_Element{,} then"

A.18.10(141/3)  "If Parent already has child nodes{,} then"

A.18.10(143/3)  "If Parent already has child nodes{,} then"

A.18.10(145/3)  "If Parent already has child nodes{,} then"

A.18.10(153/3)  "If Parent already has child nodes{,} then"

A.18.10(155/3)  "If Parent already has child nodes{,} then"

A.18.10(156/3)  "If Parent already has child nodes{,} then"

A.18.10(158/3)  "If Parent already has child nodes{,} then"

A.18.10(164/3)  "If Target_Parent already has child nodes{,} then"

A.18.10(165/3)  "If Target_Parent already has child nodes{,} then"

A.18.10(167/3)  "If Target_Parent already has child nodes{,} then"

A.18.19(11/3)   "following conditions{,} then"

A.18.20(15/3)   "following conditions{,} then"

A.18.21(16/3)   "following conditions{,} then"

A.18.22(13/3)   "following conditions{,} then"

A.18.23(16/3)   "following conditions{,} then"

A.18.24(13/3)   "following conditions{,} then"

A.18.25(15/3)   "following conditions{,} then"

A.19(11/3)      "from the environment{,} then"

A.19(12/3)      "from the environment{,} then"


B.3(60.15/1)    "If a type is C_Pass_By_Copy-compatible{,} then"

B.3.1(34)       "If Item = Null_Ptr{,} then"

B.3.1(36/1)     "If Item = Null_Ptr{,} then"

B.4(63/1)       "digit characters{,} then"


D.2.4(2.3/3)    "than the calling task{,} then"

D.2.6(13/2)     "If there is no Relative_Deadline pragma{,} then"    

D.2.6(33/2)     "policy EDF_Across_Priorities{,} then"

D.5.2(5/2)      "is in effect{,} then"

D.14.1(28/2)    "If this limit is exceeded{,} then"

D.14.2(32/2)    "when it terminates{,} then"

D.15(15/3)      "in the past{,} then"

D.16(15/3)      "is Not_A_Specific_CPU{,} then"


G.2.3(14)       "otherwise, if truncation applies{,} then"
                "whereas if rounding applies{,} then"

G.3(88/2)       "if this is done{,} then"

G.3.2(158/2)    "if this is done{,} then"


H.6(6/2)        "for a partition{,} then"

H.6(15/2)       "during elaboration{,} then"

H.6(16/2)       "task activation fails{,} then"


M.3(130/2)      "during elaboration{,} then"



Uncapitalized "False":
----------------------

11.5(2)         "when the condition being checked is [false]{False}, ..."

13.3(73.4/3)    "it is [false]{False} otherwise."

Actually, for consistency with similar rules, it would be better to move the "otherwise" to the beginning:  "otherwise, it is False".

13.3(73.8/3)    "it is [false]{False} otherwise."

Same comment as for 13.3(73.4/3).

K(83.4/3)       "it is [false]{False} otherwise."

Same comment as for 13.3(73.4/3).

K(172.4/3)      "it is [false]{False} otherwise."

Same comment as for 13.3(73.4/3).


Uncapitalized "True":
---------------------

4.5.2(38)     Three instances of "true" in example comments that should "True".

13.3(73.4/3)  "and returns [true]{True} if"

13.3(73.8/3)  "and returns [true]{True} if"

K(83.4/3)     "and returns [true]{True} if"

K(172.4/3)    "and returns [true]{True} if"

M.3(119/2)    "If Real'Signed_Zeros is [true]{True}"

M.3(120/2)    "If Complex_Types.Real'Signed_Zeros is [true]{True}"


One AARM typo I noticed:
------------------------

AARM E.2.2(20.c/2)  Typo: "(otherwise there would be a signficant..."

"signficant" => "significant"

---(end of list of RM corrections)---

****************************************************************


Questions? Ask the ACAA Technical Agent