Version 1.12 of ai12s/ai12-0302-1.txt

Unformatted version of ai12s/ai12-0302-1.txt version 1.12
Other versions for file ai12s/ai12-0302-1.txt

!standard 3.9(6/2) 20-07-21 AI12-0302-1/07
!standard 3.9(18.2/3)
!standard 9.6(10)
!standard 9.6.1(2/2)
!standard 9.6.1(8/2)
!standard 9.6.1(15/2)
!standard 11.4.1(2/2)
!standard 13.7.2(2)
!standard 13.11.2(3/3)
!standard 13.13.1(9)
!standard 13.13.4(3/3)
!standard 13.13.4(10/3)
!standard 13.13.4(11/3)
!standard 13.13.5(3/3)
!standard A.4.3(5)
!standard A.4.4(3)
!standard A.4.5(3)
!standard A.4.7(3)
!standard A.4.7(46.2/2)
!standard A.4.8(3)
!standard A.4.8(50/2)
!standard A.4.9(7/3)
!standard A.4.9(10/3)
!standard A.4.9(11.7/3)
!standard A.4.9(11.10/3)
!standard A.4.10(7/3)
!standard A.4.10(10/3)
!standard A.4.10(18/3)
!standard A.4.10(21/3)
!standard A.5.2(5)
!standard A.5.2(8)
!standard A.5.2(9)
!standard A.5.2(12)
!standard A.5.2(17)
!standard A.5.2(20)
!standard A.5.2(21)
!standard A.5.2(24)
!standard A.5.6(0)
!standard A.5.7(0)
!standard A.8.1(2)
!standard A.8.1(10.1/4)
!standard A.8.1(12)
!standard A.8.4(2)
!standard A.8.4(10.1/4)
!standard A.8.4(12)
!standard A.8.4(13)
!standard A.8.4(14)
!standard A.9(3)
!standard A.10.1(2)
!standard A.10.1(21/1)
!standard A.10.1(23)
!standard A.10.1(24)
!standard A.10.1(25)
!standard A.10.1(26)
!standard A.10.1(28)
!standard A.10.1(29)
!standard A.10.1(30)
!standard A.10.1(31)
!standard A.10.1(32)
!standard A.10.1(35)
!standard A.10.1(36)
!standard A.10.1(37)
!standard A.10.1(38)
!standard A.10.1(39)
!standard A.10.1(41)
!standard A.10.1(42)
!standard A.10.1(43)
!standard A.10.1(44)
!standard A.10.1(45)
!standard A.10.1(47)
!standard A.10.1(48)
!standard A.10.1(49)
!standard A.10.1(54)
!standard A.10.1(55)
!standard A.10.1(59)
!standard A.10.1(60)
!standard A.10.1(65)
!standard A.10.1(66)
!standard A.10.1(70)
!standard A.10.1(71)
!standard A.10.1(75)
!standard A.10.1(76)
!standard A.10.1(81)
!standard A.10.1(82)
!standard A.10.1(49.1/2)
!standard A.10.1(50)
!standard A.10.11(3/2)
!standard A.10.12(3/2)
!standard A.12.1(3/3)
!standard A.12.1(15)
!standard A.12.1(16)
!standard A.12.1(18)
!standard A.12.1(19)
!standard A.12.1(22)
!standard A.12.2(3)
!standard A.12.3(3)
!standard A.12.4(3/2)
!standard A.15(3)
!standard A.16(3/2)
!standard A.16.1(3/3)
!standard A.17(3/2)
!standard B.3.1(3)
!standard B.3.2(4)
!standard B.4(7)
!standard C.3.2(2/3)
!standard C.3.2(12)
!standard C.7.1(2/2)
!standard C.7.2(2)
!standard C.7.3(2/2)
!standard D.2.1(1.2/3)
!standard D.2.4(2.2/3)
!standard D.2.5(4/2)
!standard D.2.6(9/2)
!standard D.5.1(3/2)
!standard D.8(3)
!standard D.10(3/2)
!standard D.10(5.2/3)
!standard D.10.1(3/3)
!standard D.11(3/2)
!standard D.14(3/2)
!standard D.14.1(3/2)
!standard D.14.2(3/2)
!standard D.14.3(3/3)
!standard D.15(3/2)
!standard D.16(3/3)
!standard D.16.1(3/3)
!standard E.5(3)
!standard E.5(23)
!standard F.3.3(3)
!standard G.1.3(3)
!class Amendment 19-01-10
!status Amendment 1-2012 19-10-30
!status WG9 Approved 22-06-22
!status ARG Approved 10-0-3 20-06-13
!status work item 20-04-30
!status ARG Approved 9-0-1 19-10-06
!status work item 19-01-10
!status received 19-01-10
!priority High
!difficulty Medium
!subject Default Global aspect for language-defined units

!summary

Language-defined units declared as Pure will be implicitly Global => null. Other units will have Global => in out synchronized. Subprograms that update the internal state of a "compound" object identified by an "in" parameter (e.g. File_Type and Generator), will have Global => overriding in out <param>. IO routines that refer implicitly to Current_Input or Current_Output will have Global => in out all, since Current_Input or Current_Output could refer to any file in the program.

!problem

In the absence of a Global aspect, the default is "Global => unspecified" unless a package is declared Pure. This is not consistent with the requirement of RM A(3/5) that language-defined (generic) packages be reentrant, nor is it consistent with portability (as we do not want the legality of code using the language-defined units to depend on implementation-defined mechanisms).

!proposal

For language-defined units declared Pure, we will have the implicit Global => null. For other packages, we will insert an explicit:

Global => in out synchronized

Below are two lists of the language-defined units. The first list is those declared Pure. The second list is of those not declared Pure. We have reviewed the second list and made certain that "Global => in out synchronized" is appropriate for each. Some will have individual operations that can be specified as Global => null, if their result is purely a function of their inputs. And some, in particular in the I/O packages, will need to indicate their use of an unknown, unsynchronized global corresponding to Current_Input or Current_Output, as explained in RM A(3.1/4). For these, ideally we could write something like:

Global => (in out Current_Input, synchronized)

Global => (in out Current_Output, synchronized)

but alas, Current_Input and Current_Output are function calls, and do not statically name an object.

So we are relegated to simply:

Global => in out all

since Current_Input and Current_Output could refer to any File_Type object anywhere in the program. This would mean any call using Current_Input or Current_Output would be considered to conflict with anything that refers to an unsynchronized global.

A more general problem has to do with parameters that are clearly "handles" or equivalent on an object with levels of indirection, as described by in AI12-0079-3, such as a File_Type, random number Generator, or a task object. Even though they are passed as IN parameters, the subprogram can clearly update their associated state. One choice is to consider all of this state as residing, unsynchronized, in the associated package, as we did above for Current_Input and Current_Output, but that would be painful, since none of the, for example, File operations would be independent even when the Files designate distinct internal files. Instead, as part of AI12-0079-3, we have explicitly permitted the notion of "overriding" an IN mode with a mode that reflects the effect on the underlying object and any levels of indirection. Hence, Put and Get become:

procedure Put (File : File_Type; Item : String) with Global => overriding in out File;

procedure Get (File : File_Type; Item : out String) with Global => overriding in out File;

Using the same approach, Random becomes:

function Random(Gen : Generator) return Result_Subtype with Global => overriding in out Gen;

Similarly, the various Reset procedures will have

... with Global => overriding in out Gen;

Finally, we have functions that return generalized references into another object, e.g.:

function Reference(Container : aliased in out Map; ...) return Reference_Type;

How do we specify that the returned reference refers to some part of Container? As part of the most recent fix-up on Global, we leave effects on visible access types to the caller. With this rule, we can specify Global => null on the above, because the "in out" mode of the Container parameter already captures the object designated by the result object.

!wording

So to summarize the wording, each library unit will have a well-defined Global aspect at the package level, being either implicitly "null" for pure library units, or explicitly "in out synchronized" for impure library units (see list of impure units below).

And then within the impure units, individual subprograms may override this default with "null" when they are certain to have no side effects other than those represented by the modes of their formal parameters (not clear it is worth defining these at this stage). Alternatively, subprograms may overide with "in [out] <unit_name>" when they refer to implicit state that is not synchronized.

For operations within a generic, we may want to specify Use_Formal => null for certain operations we know do not use the generic formals, though that seems relatively minor, since in most cases the generic actual won't have any weird Global aspects anyway.

For operations that take class-wide parameters, we may want to take advantage of the Dispatching aspect feature defined in H.7.1 to narrow the effects.

Note: We do not cover the containers packages here; their Global aspects are specified as part of AI12-0112-1, which overhauls the contracts of the containers generally.

OVERRIDING PARAMETER MODES

Here are the details for subprograms with side effects that cannot use the default associated with the enclosing impure library unit (ignoring side-effect free subprograms for now):

Within 13.11.4, Subpools:

Modify Set_Pool_Of_Subpool, Allocate_From_Subpool to have:

with Global => overriding in out Subpool;

---

Within A.5.2, Discrete_Random and Float_Random:

Modify Random, Reset to have

with Global => overriding in out Gen;

---

Within A.8.1, Sequential_IO:

Modify Flush, Read, Write to have

with Global => overriding in out File;

---

Within A.8.4, Direct_IO:

Modify Flush, Read, Write, Set_Index to have:

with Global => overriding in out File;

---

Within A.10.1, Text_IO:

Modify current input/output versions of:

Flush, Set_Line_Length, Set_Page_Length, New_Line, Skip_Line, New_Page, Skip_Page, Set_Col, Set_Line, Put, Get, Put_Line, Get_Line, Look_Ahead, Get_Immediate

to have:

with Global => in out all;

Modify File_Type versions of

Flush, Set_Line_Length, Set_Page_Length, New_Line, Skip_Line, New_Page, Skip_Page, Set_Col, Set_Line, Put, Get, Put_Line, Get_Line, Look_Ahead, Get_Immediate

to have

with Global => overriding in out File;

Modify current input/output versions of:

Line_Length, Page_Length, End_Of_Line, End_Of_Page, End_Of_File, Col, Line, Page

to have

with Global => in all;

---

Within A.12.1, Stream_IO:

Modify Read, Write, Set_Index to have:

with Global => overriding in out File;

---

--------------- The following units are Pure and do not need a Global specification: ---------------

Standard -- A.1

Ada -- A.2

Assertions 11.4.2 Characters -- A.3.1

Conversions -- A.3.4 Handling -- A.3.2 Latin_1 -- A.3.3

Containers -- A.18.1

Bounded_Doubly_Linked_Lists -- A.18.20 Bounded_Hashed_Maps -- A.18.21 Bounded_Hashed_Sets -- A.18.23 Bounded_Multiway_Trees -- A.18.25 Bounded_Ordered_Maps -- A.18.22 Bounded_Ordered_Sets -- A.18.24 Bounded_Vectors -- A.18.19 Generic_Array_Sort -- A.18.26 Generic_Constrained_Array_Sort -- A.18.26 Generic_Sort -- A.18.26

Synchronized_Queue_Interfaces

-- A.18.27

Decimal -- F.2 Finalization -- 7.6 IO_Exceptions -- A.13 Iterator_Interfaces -- 5.5.1 Locales -- A.19 Numerics -- A.5

Big_Numbers -- A.5.5 Complex_Arrays -- G.3.2 Complex_Elementary_Functions -- G.1.2 Complex_Types -- G.1.1 Elementary_Functions -- A.5.1 Generic_Complex_Arrays -- G.3.2 Generic_Complex_Elementary_Functions -- G.1.2 Generic_Complex_Types -- G.1.1 Generic_Elementary_Functions -- A.5.1 Generic_Real_Arrays -- G.3.1 Real_Arrays -- G.3.1

Streams -- 13.13.1

Storage -- 13.13.1 Bounded -- 13.13.1

Strings -- A.4.1

Equal_Case_Insensitive -- A.4.10 Hash -- A.4.9 Hash_Case_Insensitive -- A.4.9 Less_Case_Insensitive -- A.4.10 Maps -- A.4.2 Constants -- A.4.6 UTF_Encoding -- A.4.11 Conversions -- A.4.11 Strings -- A.4.11 Wide_Strings -- A.4.11 Wide_Wide_Strings -- A.4.11 Wide_Equal_Case_Insensitive -- A.4.7 Wide_Hash -- A.4.7 Wide_Hash_Case_Insensitive -- A.4.7 Wide_Wide_Equal_Case_Insensitive -- A.4.8 Wide_Wide_Hash -- A.4.8 Wide_Wide_Hash_Case_Insensitive -- A.4.8

Unchecked_Conversion -- 13.9 Unchecked_Deallocate_Subpool -- 13.11.5 Unchecked_Deallocation -- 13.11.2 Wide_Characters -- A.3.1

Handling -- A.3.5

Wide_Wide_Characters -- A.3.1

Handling -- A.3.6

Interfaces -- B.2

C -- B.3 Fortran -- B.5

System -- 13.7

Atomic_Operations -- C.6.1 Arithmetic -- C.6.4 Exchange -- C.6.2 Test_And_Set -- C.6.2 Storage_Elements -- 13.7.1 Storage_Pools -- 13.11

----------------- The following units are not Pure and need a Global specification of Global => in out synchronized: -----------------

[Ada]

Asynchronous_Task_Control -- D.11 Calendar -- 9.6

Arithmetic -- 9.6.1 Formatting -- 9.6.1 Time_Zones -- 9.6.1

Command_Line -- A.15 Complex_Text_IO -- G.1.3 [Containers]

Bounded_Indefinite_Holders -- A.18.32 Bounded_Priority_Queues -- A.18.31 Bounded_Synchronized_Queues -- A.18.29 Doubly_Linked_Lists -- A.18.3 Hashed_Maps -- A.18.5 Hashed_Sets -- A.18.8 Indefinite_Doubly_Linked_Lists -- A.18.12 Indefinite_Hashed_Maps -- A.18.13 Indefinite_Hashed_Sets -- A.18.15 Indefinite_Holders -- A.18.18 Indefinite_Multiway_Trees -- A.18.17 Indefinite_Ordered_Maps -- A.18.14 Indefinite_Ordered_Sets -- A.18.16 Indefinite_Vectors -- A.18.11Standard (...continued) Multiway_Trees -- A.18.10 Ordered_Maps -- A.18.6 Ordered_Sets -- A.18.9 Unbounded_Priority_Queues -- A.18.30 Unbounded_Synchronized_Queues -- A.18.28 Vectors -- A.18.2

Direct_IO -- A.8.4 Directories -- A.16

Hierarchical_File_Names -- A.16.1 Information -- A.16

Dispatching -- D.2.1

EDF -- D.2.6 Non_Preemptive -- D.2.4 Round_Robin -- D.2.5

Dynamic_Priorities -- D.5.1 Environment_Variables -- A.17 Exceptions -- 11.4.1 Execution_Time -- D.14

Group_Budgets -- D.14.2 Interrupts -- D.14.3 Timers -- D.14.1

Float_Text_IO -- A.10.9 Float_Wide_Text_IO -- A.11 Float_Wide_Wide_Text_IO -- A.11 Integer_Text_IO -- A.10.8 Integer_Wide_Text_IO -- A.11 Integer_Wide_Wide_Text_IO -- A.11 Interrupts -- C.3.2

Names -- C.3.2

[Numerics]

Big_Integers -- A.5.6 Big_Reals -- A.5.7 Discrete_Random -- A.5.2 Float_Random -- A.5.2

Real_Time -- D.8

Timing_Events -- D.15

Sequential_IO -- A.8.1 Storage_IO -- A.9 [Streams]

Stream_IO -- A.12.1 [Storage] Unbounded -- 13.13.1

[Strings]

Bounded -- A.4.4 Equal_Case_Insensitive -- A.4.10 Hash -- A.4.9 Hash_Case_Insensitive -- A.4.9 Less_Case_Insensitive -- A.4.10 Fixed -- A.4.3 Equal_Case_Insensitive -- A.4.10 Hash -- A.4.9 Hash_Case_Insensitive -- A.4.9 Less_Case_Insensitive -- A.4.10 Unbounded -- A.4.5 Equal_Case_Insensitive -- A.4.10 Hash -- A.4.9 Hash_Case_Insensitive -- A.4.9 Less_Case_Insensitive -- A.4.10 Wide_Bounded -- A.4.7 Wide_Equal_Case_Insensitive -- A.4.7 Wide_Hash -- A.4.7 Wide_Hash_Case_Insensitive -- A.4.7 Wide_Fixed -- A.4.7 Wide_Equal_Case_Insensitive -- A.4.7 Wide_Hash -- A.4.7 Wide_Hash_Case_Insensitive -- A.4.7 Wide_Maps -- A.4.7 Wide_Constants -- A.4.7 Wide_Unbounded -- A.4.7 Wide_Equal_Case_Insensitive -- A.4.7 Wide_Hash -- A.4.7 Wide_Hash_Case_Insensitive -- A.4.7 Wide_Wide_Bounded -- A.4.8 Wide_Wide_Equal_Case_Insensitive -- A.4.8 Wide_Wide_Hash -- A.4.8 Wide_Wide_Hash_Case_Insensitive -- A.4.8 Wide_Wide_Fixed -- A.4.8 Wide_Wide_Equal_Case_Insensitive -- A.4.8 Wide_Wide_Hash -- A.4.8 Wide_Wide_Hash_Case_Insensitive -- A.4.8 Wide_Wide_Maps -- A.4.8 Wide_Wide_Constants -- A.4.8 Wide_Wide_Unbounded -- A.4.8 Wide_Wide_Equal_Case_Insensitive -- A.4.8 Wide_Wide_Hash -- A.4.8 Wide_Wide_Hash_Case_Insensitive -- A.4.8

Synchronous_Barriers -- D.10.1 Synchronous_Task_Control -- D.10

EDF -- D.10

Tags -- 3.9

Generic_Dispatching_Constructor -- 3.9

Task_Attributes -- C.7.2 Task_Identification -- C.7.1 Task_Termination -- C.7.3 Text_IO -- A.10.1

Bounded_IO -- A.10.11 Complex_IO -- G.1.3 Editing -- F.3.3 Text_Streams -- A.12.2 Unbounded_IO -- A.10.12

Unchecked_Deallocate_Subpool -- 13.11.5 Unchecked_Deallocation -- 13.11.2 Wide_Command_Line -- A.15.1 Wide_Directories -- A.16.2 Wide_Environment_Variables -- A.17.1 Wide_Text_IO -- A.11

Complex_IO -- G.1.4 Editing -- F.3.4 Text_Streams -- A.12.3 Wide_Bounded_IO -- A.11 Wide_Unbounded_IO -- A.11

Wide_Wide_Text_IO -- A.11

Complex_IO -- G.1.5 Editing -- F.3.5 Text_Streams -- A.12.4 Wide_Wide_Bounded_IO -- A.11 Wide_Wide_Unbounded_IO -- A.11

Wide_Wide_Command_Line -- A.15.1 Wide_Wide_Directories -- A.16.2 Wide_Wide_Environment_Variables -- A.17.1

[Interfaces]

[C]

Pointers -- B.3.2 Strings -- B.3.1

COBOL -- B.4

[System]

Address_To_Access_Conversions -- 13.7.2 Machine_Code -- 13.8 Multiprocessors -- D.16

Dispatching_Domains -- D.16.1

RPC -- E.5 [Storage_Pools]

Subpools -- 13.11.4

!discussion

The rules given in RM A(3/5-3.1/4) ensure that any globals referenced by language-defined packages are synchronized, except in the special case of the files identified by Current_Input and Current_Output. For these, as proposed above, we will specify the side effects using an appropriate mode with group designator "all". Also, for cases where a parameter mode of IN is used for an operand that clearly is associated with updatable state, a Global aspect of the form OVERRIDING IN OUT Param will be used to capture the fact that some potentially non-synchronized state is being updated that is designated by the given Param.

See the !proposal for more discussion and rationale.

!corrigendum 3.9(6/2)

Replace the paragraph:

package Ada.Tags is pragma Preelaborate(Tags); type Tag is private; pragma Preelaborable_Initialization(Tag);

by:

package Ada.Tags with Preelaborate, Nonblocking, Global => in out synchronized is type Tag is private; pragma Preelaborable_Initialization(Tag);

!corrigendum 3.9(18.2/3)

Replace the paragraph:

generic type T (<>) is abstract tagged limited private; type Parameters (<>) is limited private; with function Constructor (Params : not null access Parameters) return T is abstract; function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : not null access Parameters) return T'Class with Convention => Intrinsic; pragma Preelaborate(Generic_Dispatching_Constructor);

by:

generic type T (<>) is abstract tagged limited private; type Parameters (<>) is limited private; with function Constructor (Params : not null access Parameters) return T is abstract; function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : not null access Parameters) return T'Class with Preelaborate, Convention => Intrinsic, Nonblocking, Global => in out synchronized;

!corrigendum 9.6(10)

Replace the paragraph:

package Ada.Calendar is type Time is private;

by:

package Ada.Calendar with Nonblocking, Global => in out synchronized is type Time is private;

!corrigendum 9.6.1(2/2)

Replace the paragraph:

package Ada.Calendar.Time_Zones is

by:

package Ada.Calendar.Time_Zones with Nonblocking, Global => in out synchronized is

!corrigendum 9.6.1(8/2)

Replace the paragraph:

package Ada.Calendar.Arithmetic is

by:

package Ada.Calendar.Arithmetic with Nonblocking, Global => in out synchronized is

!corrigendum 9.6.1(15/2)

Replace the paragraph:

with Ada.Calendar.Time_Zones; package Ada.Calendar.Formatting is

by:

with Ada.Calendar.Time_Zones; package Ada.Calendar.Formatting with Nonblocking, Global => in out synchronized is

!corrigendum 11.4.1(2/2)

Replace the paragraph:

with Ada.Streams; package Ada.Exceptions is pragma Preelaborate(Exceptions); type Exception_Id is private; pragma Preelaborable_Initialization(Exception_Id); Null_Id : constant Exception_Id; function Exception_Name(Id : Exception_Id) return String; function Wide_Exception_Name(Id : Exception_Id) return Wide_String; function Wide_Wide_Exception_Name(Id : Exception_Id) return Wide_Wide_String;

by:

with Ada.Streams; package Ada.Exceptions with Preelaborate, Nonblocking, Global => in out synchronized is type Exception_Id is private; pragma Preelaborable_Initialization(Exception_Id); Null_Id : constant Exception_Id; function Exception_Name(Id : Exception_Id) return String; function Wide_Exception_Name(Id : Exception_Id) return Wide_String; function Wide_Wide_Exception_Name(Id : Exception_Id) return Wide_Wide_String;

!corrigendum 13.7.2(2)

Replace the paragraph:

generic type Object(<>) is limited private; package System.Address_To_Access_Conversions is pragma Preelaborate(Address_To_Access_Conversions);

by:

generic type Object(<>) is limited private; package System.Address_To_Access_Conversions with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum 13.11.2(3/3)

Replace the paragraph:

generic type Object(<>) is limited private; type Name is access Object; procedure Ada.Unchecked_Deallocation(X : in out Name) with Convention => Intrinsic; pragma Preelaborate(Ada.Unchecked_Deallocation);

by:

generic type Object(<>) is limited private; type Name is access Object; procedure Ada.Unchecked_Deallocation(X : in out Name) with Preelaborate, Nonblocking, Convention => Intrinsic, Global => in out synchronized;

!corrigendum 13.11.4(3/3)

Replace the paragraph:

package System.Storage_Pools.Subpools is pragma Preelaborate (Subpools);

by:

package System.Storage_Pools.Subpools with Preelaborate, Global => in out synchronized is

!corrigendum 13.11.4(10/3)

Replace the paragraph:

procedure Set_Pool_of_Subpool ( Subpool : in not null Subpool_Handle; To : in out Root_Storage_Pool_With_Subpools'Class);

by:

procedure Set_Pool_of_Subpool ( Subpool : in not null Subpool_Handle; To : in out Root_Storage_Pool_With_Subpools'Class) with Global => overriding in out Subpool;

!corrigendum 13.11.4(11/3)

Replace the paragraph:

procedure Allocate_From_Subpool ( Pool : in out Root_Storage_Pool_With_Subpools; Storage_Address : out Address; Size_In_Storage_Elements : in Storage_Elements.Storage_Count; Alignment : in Storage_Elements.Storage_Count; Subpool : in not null Subpool_Handle) is abstract with Pre'Class => Pool_of_Subpool(Subpool) = Pool'Access;

by:

!corrigendum 13.11.5(3/3)

!comment see the AARM note for why this is "in out all".

@drepl @xcode<@b<with> System.Storage_Pools.Subpools; @b<procedure> Ada.Unchecked_Deallocate_Subpool

(Subpool : @b<in out> System.Storage_Pools.Subpools.Subpool_Handle);>

@dby @xcode<@b<with> System.Storage_Pools.Subpools; @b<procedure> Ada.Unchecked_Deallocate_Subpool

(Subpool : @b<in out> System.Storage_Pools.Subpools.Subpool_Handle) @b<with> Global =@> @b<in out all>;>

!corrigendum 13.13.1(9)

Insert after the paragraph:

The Write operation appends Item to the specified stream.

the new paragraphs:

See the conflict file for the text.

!corrigendum A.4.3(5)

Replace the paragraph:

with Ada.Strings.Maps; package Ada.Strings.Fixed is pragma Preelaborate(Fixed);

by:

with Ada.Strings.Maps; package Ada.Strings.Fixed with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.4.4(3)

Replace the paragraph:

with Ada.Strings.Maps; package Ada.Strings.Bounded is pragma Preelaborate(Bounded);

by:

with Ada.Strings.Maps; package Ada.Strings.Bounded with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.4.5(3)

Replace the paragraph:

with Ada.Strings.Maps; package Ada.Strings.Unbounded is pragma Preelaborate(Unbounded);

by:

with Ada.Strings.Maps; package Ada.Strings.Unbounded with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.4.7(3)

Replace the paragraph:

package Ada.Strings.Wide_Maps is pragma Preelaborate(Wide_Maps);

by:

package Ada.Strings.Wide_Maps with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.4.7(46.2/2)

Replace the paragraph:

Pragma

Pure is replaced by pragma Preelaborate in Strings.Wide_Maps.Wide_Constants.

by:

Pragma

Pure is replaced by aspects with Preelaborate, Nonblocking, Global => in out synchronized in Strings.Wide_Maps.Wide_Constants.

!corrigendum A.4.8(3/2)

Replace the paragraph:

package Ada.Strings.Wide_Wide_Maps is pragma Preelaborate(Wide_Wide_Maps);

by:

package Ada.Strings.Wide_Wide_Maps with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.4.8(50/2)

Replace the paragraph:

Pragma

Pure is replaced by pragma Preelaborate in Strings.Wide_Maps.Wide_Constants.

by:

Pragma

Pure is replaced by aspects with Preelaborate, Nonblocking, Global => in out synchronized in Strings.Wide_Wide_Maps.Wide_Wide_Constants.

!corrigendum A.4.9(7/3)

Replace the paragraph:

with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Bounded.Hash);

by:

with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.9(10/3)

Replace the paragraph:

with Ada.Containers; function Ada.Strings.Unbounded.Hash (Key : Unbounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Unbounded.Hash);

by:

with Ada.Containers; function Ada.Strings.Unbounded.Hash (Key : Unbounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.9(11.7/3)

Replace the paragraph:

with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Bounded.Hash_Case_Insensitive);

by:

with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.9(11.10/3)

Replace the paragraph:

with Ada.Containers; function Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Unbounded.Hash_Case_Insensitive);

by:

with Ada.Containers; function Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.10(7/3)

Replace the paragraph:

generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Bounded.Equal_Case_Insensitive);

by:

generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.10(10/3)

Replace the paragraph:

function Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Unbounded.Equal_Case_Insensitive);

by:

function Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) return Boolean with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.10(18/3)

Replace the paragraph:

generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Bounded.Less_Case_Insensitive);

by:

generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.4.10(21/3)

Replace the paragraph:

function Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Unbounded.Less_Case_Insensitive);

by:

function Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) return Boolean with Preelaborate, Nonblocking, Global => in out synchronized;

!corrigendum A.5.2(5)

Replace the paragraph:

package Ada.Numerics.Float_Random is

by:

package Ada.Numerics.Float_Random with Global => in out synchronized is

!comment A.5.2(8) is not provided here.

!comment A.5.2(9) is not provided here.

!comment A.5.2(12) is not provided here.

!corrigendum A.5.2(17)

Replace the paragraph:

generic type Result_Subtype is (<>); package Ada.Numerics.Discrete_Random is

by:

generic type Result_Subtype is (<>); package Ada.Numerics.Discrete_Random with Global => in out synchronized is

!corrigendum A.5.2(20)

Replace the paragraph:

function Random (Gen : Generator) return Result_Subtype;

by:

function Random (Gen : Generator) return Result_Subtype with Global => overriding in out Gen;

function Random (Gen : Generator; First : Result_Subtype; Last : Result_Subtype) return Result_Subtype with Post => Random'Result in First .. Last, Global => overriding in out Gen;

!comment A.5.2(21) is not provided here.

!comment A.5.2(24) is not provided here.

!corrigendum A.5.6(0)

Insert new clause:

See the conflict file for the changes.

!corrigendum A.5.7(0)

Insert new clause:

See the conflict file for the changes.

!comment A.8.1(2) is not provided here.

!comment A.8.1(10.1/4) is not provided here.

!comment A.8.1(12) is not provided here.

!comment A.8.4(2) is not provided here.

!comment A.8.4(10.1/4) is not provided here.

!comment A.8.4(12) is not provided here.

!comment A.8.4(13) is not provided here.

!comment A.8.4(14) is not provided here.

!comment A.9(3) is not provided here.

!comment A.10.1(2) not provided here.

!comment A.10.1(21/1) not provided here.

!comment A.10.1(23) not provided here.

!comment A.10.1(24) not provided here.

!comment A.10.1(25) not provided here.

!comment A.10.1(26) not provided here.

!comment A.10.1(28) not provided here.

!comment A.10.1(29) not provided here.

!comment A.10.1(30) not provided here.

!comment A.10.1(31) not provided here.

!comment A.10.1(32) not provided here.

!comment A.10.1(35) not provided here.

!comment A.10.1(36) not provided here.

!comment A.10.1(37) not provided here.

!comment A.10.1(38) not provided here.

!comment A.10.1(39) not provided here.

!comment A.10.1(41) not provided here.

!comment A.10.1(42) not provided here.

!comment A.10.1(43) not provided here.

!comment A.10.1(44) not provided here.

!comment A.10.1(45) not provided here.

!comment A.10.1(43) not provided here.

!comment A.10.1(47) not provided here.

!comment A.10.1(48) not provided here.

!comment A.10.1(49) not provided here.

!comment A.10.1(49.1/2) not provided here.

!comment A.10.1(50) not provided here.

!corrigendum A.10.1(54)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0); procedure Get(Item : out Num; Width : in Field := 0);

by:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0) with Global => overriding in out File; procedure Get(Item : out Num; Width : in Field := 0) with Global => in out all;

!corrigendum A.10.1(55)

Replace the paragraph:

procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Put(Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Base : in Number_Base := Default_Base);

by:

procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base) with Global => overriding in out File; procedure Put(Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base) with Global => in out all; procedure Get(From : in String; Item : out Num; Last : out Positive) with Nonblocking; procedure Put(To : out String; Item : in Num; Base : in Number_Base := Default_Base) with Nonblocking;

!corrigendum A.10.1(59)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0); procedure Get(Item : out Num; Width : in Field := 0);

by:

!corrigendum A.10.1(60)

Replace the paragraph:

by:

!corrigendum A.10.1(65)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0); procedure Get(Item : out Num; Width : in Field := 0);

by:

!corrigendum A.10.1(66)

Replace the paragraph:

procedure Put(File : in File_Type; Item : in Num; Fore : in Field := Default_Fore; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp); procedure Put(Item : in Num; Fore : in Field := Default_Fore; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp);

by:

procedure Put(File : in File_Type; Item : in Num; Fore : in Field := Default_Fore; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp) with Global => overriding in out File; procedure Put(Item : in Num; Fore : in Field := Default_Fore; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp) with Global => in out all;

!corrigendum A.10.1(70)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0); procedure Get(Item : out Num; Width : in Field := 0);

by:

!corrigendum A.10.1(71)

Replace the paragraph:

by:

!corrigendum A.10.1(75)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Num; Width : in Field := 0); procedure Get(Item : out Num; Width : in Field := 0);

by:

!corrigendum A.10.1(76)

Replace the paragraph:

by:

!corrigendum A.10.1(81)

Replace the paragraph:

procedure Get(File : in File_Type; Item : out Enum); procedure Get(Item : out Enum);

by:

procedure Get(File : in File_Type; Item : out Enum) with Global => overriding in out File; procedure Get(Item : out Enum) with Global => in out all;

!corrigendum A.10.1(82)

Replace the paragraph:

procedure Put(File : in File_Type; Item : in Enum; Width : in Field := Default_Width; Set : in Type_Set := Default_Setting); procedure Put(Item : in Enum; Width : in Field := Default_Width; Set : in Type_Set := Default_Setting);

by:

procedure Put(File : in File_Type; Item : in Enum; Width : in Field := Default_Width; Set : in Type_Set := Default_Setting) with Global => overriding in out File; procedure Put(Item : in Enum; Width : in Field := Default_Width; Set : in Type_Set := Default_Setting) with Global => in out all;

!comment A.10.11(3/2) is not provided here.

!comment A.10.12(3/2) is not provided here.

!comment A.12.1(3/3) is not provided here.

!comment A.12.1(15) is not provided here.

!comment A.12.1(16) is not provided here.

!comment A.12.1(18) is not provided here.

!comment A.12.1(19) is not provided here.

!comment A.12.1(22) is not provided here.

!comment A.12.2(3) is not provided here.

!comment A.12.3(3) is not provided here.

!comment A.12.4(3/2) is not provided here.

!corrigendum A.15(3)

Replace the paragraph:

package Ada.Command_Line is pragma Preelaborate(Command_Line);

by:

package Ada.Command_Line with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum A.16(3/2)

Replace the paragraph:

with Ada.IO_Exceptions; with Ada.Calendar; package Ada.Directories is

by:

with Ada.IO_Exceptions; with Ada.Calendar; package Ada.Directories with Global => in out synchronized is

!corrigendum A.16.1(3/3)

Replace the paragraph:

package Ada.Directories.Hierarchical_File_Names is

by:

package Ada.Directories.Hierarchical_File_Names with Nonblocking, Global => in out synchronized is

!corrigendum A.17(3/2)

Replace the paragraph:

package Ada.Environment_Variables is pragma Preelaborate(Environment_Variables);

by:

package Ada.Environment_Variables with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum B.3.1(3)

Replace the paragraph:

package Interfaces.C.Strings is pragma Preelaborate(Strings);

by:

package Interfaces.C.Strings with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum B.3.2(4)

Replace the paragraph:

generic type Index is (<>); type Element is private; type Element_Array is array (Index range <>) of aliased Element; Default_Terminator : Element; package Interfaces.C.Pointers is pragma Preelaborate(Pointers);

by:

!corrigendum B.4(7)

Replace the paragraph:

package Interfaces.COBOL is pragma Preelaborate(COBOL);

by:

package Interfaces.COBOL with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum C.3.2(2/3)

Replace the paragraph:

with System; with System.Multiprocessors; package Ada.Interrupts is type Interrupt_Id is implementation-defined; type Parameterless_Handler is access protected procedure;

by:

with System; with System.Multiprocessors; package Ada.Interrupts with Nonblocking, Global => in out synchronized is type Interrupt_Id is implementation-defined; type Parameterless_Handler is access protected procedure with Nonblocking => False;

!corrigendum C.3.2(12)

Replace the paragraph:

package Ada.Interrupts.Names is implementation-defined : constant Interrupt_Id := implementation-defined; . . . implementation-defined : constant Interrupt_Id := implementation-defined; end Ada.Interrupts.Names;

by:

package Ada.Interrupts.Names with Nonblocking, Global => null is implementation-defined : constant Interrupt_Id := implementation-defined; . . . implementation-defined : constant Interrupt_Id := implementation-defined; end Ada.Interrupts.Names;

!corrigendum C.7.1(2/2)

Replace the paragraph:

package Ada.Task_Identification is pragma Preelaborate(Task_Identification); type Task_Id is private; pragma Preelaborable_Initialization (Task_Id); Null_Task_Id : constant Task_Id; function "=" (Left, Right : Task_Id) return Boolean;

by:

package Ada.Task_Identification with Preelaborate, Nonblocking, Global => in out synchronized is type Task_Id is private; pragma Preelaborable_Initialization (Task_Id); Null_Task_Id : constant Task_Id; function "=" (Left, Right : Task_Id) return Boolean;

!corrigendum C.7.2(2)

Replace the paragraph:

with Ada.Task_Identification; use Ada.Task_Identification; generic type Attribute is private; Initial_Value : in Attribute; package Ada.Task_Attributes is

by:

with Ada.Task_Identification; use Ada.Task_Identification; generic type Attribute is private; Initial_Value : in Attribute; package Ada.Task_Attributes with Nonblocking, Global => in out synchronized is

!corrigendum C.7.3(2/2)

Replace the paragraph:

with Ada.Task_Identification; with Ada.Exceptions; package Ada.Task_Termination is pragma Preelaborate(Task_Termination);

by:

with Ada.Task_Identification; with Ada.Exceptions; package Ada.Task_Termination with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.2.1(1.2/3)

Replace the paragraph:

package Ada.Dispatching is pragma Preelaborate(Dispatching);

by:

package Ada.Dispatching with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.2.4(2.2/3)

Replace the paragraph:

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;

by:

package Ada.Dispatching.Non_Preemptive with Preelaborate, Nonblocking, Global => in out synchronized is procedure Yield_To_Higher; procedure Yield_To_Same_Or_Higher renames Yield; end Ada.Dispatching.Non_Preemptive;

!corrigendum D.2.5(4/2)

Replace the paragraph:

with System; with Ada.Real_Time; package Ada.Dispatching.Round_Robin is Default_Quantum : constant Ada.Real_Time.Time_Span := implementation-defined; procedure Set_Quantum (Pri : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); procedure Set_Quantum (Low, High : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); function Actual_Quantum (Pri : System.Priority) return Ada.Real_Time.Time_Span; function Is_Round_Robin (Pri : System.Priority) return Boolean; end Ada.Dispatching.Round_Robin;

by:

with System; with Ada.Real_Time; package Ada.Dispatching.Round_Robin with Nonblocking, Global => in out synchronized is Default_Quantum : constant Ada.Real_Time.Time_Span := implementation-defined; procedure Set_Quantum (Pri : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); procedure Set_Quantum (Low, High : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); function Actual_Quantum (Pri : System.Priority) return Ada.Real_Time.Time_Span; function Is_Round_Robin (Pri : System.Priority) return Boolean; end Ada.Dispatching.Round_Robin;

!corrigendum D.2.6(9/2)

Replace the paragraph:

with Ada.Real_Time; with Ada.Task_Identification; package Ada.Dispatching.EDF is subtype Deadline is Ada.Real_Time.Time; Default_Deadline : constant Deadline := Ada.Real_Time.Time_Last; procedure Set_Deadline (D : in Deadline; T : in Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); procedure Delay_Until_And_Set_Deadline ( Delay_Until_Time : in Ada.Real_Time.Time; Deadline_Offset : in Ada.Real_Time.Time_Span); function Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) return Deadline; end Ada.Dispatching.EDF;

by:

with Ada.Real_Time; with Ada.Task_Identification; package Ada.Dispatching.EDF with Nonblocking, Global => in out synchronized is subtype Deadline is Ada.Real_Time.Time; Default_Deadline : constant Deadline := Ada.Real_Time.Time_Last; procedure Set_Deadline (D : in Deadline; T : in Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); procedure Delay_Until_And_Set_Deadline ( Delay_Until_Time : in Ada.Real_Time.Time; Deadline_Offset : in Ada.Real_Time.Time_Span) with Nonblocking => False; function Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) return Deadline; end Ada.Dispatching.EDF;

!corrigendum D.5.1(3/2)

Replace the paragraph:

with System; with Ada.Task_Identification; -- See C.7.1 package Ada.Dynamic_Priorities is pragma Preelaborate(Dynamic_Priorities);

by:

with System; with Ada.Task_Identification; -- See C.7.1 package Ada.Dynamic_Priorities with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.8(3)

Replace the paragraph:

package Ada.Real_Time is

by:

package Ada.Real_Time with Nonblocking, Global => in out synchronized is

!corrigendum D.10(3/2)

Replace the paragraph:

package Ada.Synchronous_Task_Control is pragma Preelaborate(Synchronous_Task_Control);

by:

package Ada.Synchronous_Task_Control with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.10(5.2/3)

Replace the paragraph:

with Ada.Real_Time; package Ada.Synchronous_Task_Control.EDF is procedure Suspend_Until_True_And_Set_Deadline (S : in out Suspension_Object; TS : in Ada.Real_Time.Time_Span); end Ada.Synchronous_Task_Control.EDF;

by:

with Ada.Real_Time; package Ada.Synchronous_Task_Control.EDF with Nonblocking, Global => in out synchronized is procedure Suspend_Until_True_And_Set_Deadline (S : in out Suspension_Object; TS : in Ada.Real_Time.Time_Span) with Nonblocking => False; end Ada.Synchronous_Task_Control.EDF;

!corrigendum D.10.1(3/3)

Replace the paragraph:

package Ada.Synchronous_Barriers is pragma Preelaborate(Synchronous_Barriers);

by:

package Ada.Synchronous_Barriers with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.11(3/2)

Replace the paragraph:

with Ada.Task_Identification; package Ada.Asynchronous_Task_Control is pragma Preelaborate(Asynchronous_Task_Control); procedure Hold(T : in Ada.Task_Identification.Task_Id); procedure Continue(T : in Ada.Task_Identification.Task_Id); function Is_Held(T : Ada.Task_Identification.Task_Id) return Boolean; end Ada.Asynchronous_Task_Control;

by:

with Ada.Task_Identification; package Ada.Asynchronous_Task_Control with Preelaborate, Nonblocking, Global => in out synchronized is procedure Hold(T : in Ada.Task_Identification.Task_Id); procedure Continue(T : in Ada.Task_Identification.Task_Id); function Is_Held(T : Ada.Task_Identification.Task_Id) return Boolean; end Ada.Asynchronous_Task_Control;

!corrigendum D.14(3/2)

Replace the paragraph:

with Ada.Task_Identification; with Ada.Real_Time; use Ada.Real_Time; package Ada.Execution_Time is

by:

with Ada.Task_Identification; with Ada.Real_Time; use Ada.Real_Time; package Ada.Execution_Time with Nonblocking, Global => in out synchronized is

!corrigendum D.14.1(3/2)

Replace the paragraph:

with System; package Ada.Execution_Time.Timers is

by:

with System; package Ada.Execution_Time.Timers with Nonblocking, Global => in out synchronized is

!corrigendum D.14.2(3/3)

Replace the paragraph:

with System; with System.Multiprocessors; package Ada.Execution_Time.Group_Budgets is

by:

with System; with System.Multiprocessors; package Ada.Execution_Time.Group_Budgets with Nonblocking, Global => in out synchronized is

!corrigendum D.14.3(3/3)

Replace the paragraph:

with Ada.Interrupts; package Ada.Execution_Time.Interrupts is function Clock (Interrupt : Ada.Interrupts.Interrupt_Id) return CPU_Time; function Supported (Interrupt : Ada.Interrupts.Interrupt_Id) return Boolean; end Ada.Execution_Time.Interrupts;

by:

with Ada.Interrupts; package Ada.Execution_Time.Interrupts with Nonblocking, Global => in out synchronized is function Clock (Interrupt : Ada.Interrupts.Interrupt_Id) return CPU_Time; function Supported (Interrupt : Ada.Interrupts.Interrupt_Id) return Boolean; end Ada.Execution_Time.Interrupts;

!corrigendum D.15(3/2)

Replace the paragraph:

package Ada.Real_Time.Timing_Events is

by:

package Ada.Real_Time.Timing_Events with Nonblocking, Global => in out synchronized is

!corrigendum D.16(3/3)

Replace the paragraph:

package System.Multiprocessors is pragma Preelaborate(Multiprocessors);

by:

package System.Multiprocessors with Preelaborate, Nonblocking, Global => in out synchronized is

!corrigendum D.16.1(3/3)

Replace the paragraph:

with Ada.Real_Time; with Ada.Task_Identification; package System.Multiprocessors.Dispatching_Domains is

by:

with Ada.Real_Time; with Ada.Task_Identification; package System.Multiprocessors.Dispatching_Domains with Nonblocking, Global => in out synchronized is

!corrigendum E.5(3)

Replace the paragraph:

with Ada.Streams; -- see 13.13.1 package System.RPC is

by:

with Ada.Streams; -- see 13.13.1 package System.RPC with Nonblocking => False, Global => in out synchronized is

!corrigendum F.3.3(3)

Replace the paragraph:

package Ada.Text_IO.Editing is

by:

package Ada.Text_IO.Editing with Nonblocking, Global => in out synchronized is

!corrigendum G.1.3(3)

Replace the paragraph:

with Ada.Numerics.Generic_Complex_Types; generic with package Complex_Types is new Ada.Numerics.Generic_Complex_Types (<>); package Ada.Text_IO.Complex_IO is

by:

with Ada.Numerics.Generic_Complex_Types; generic with package Complex_Types is new Ada.Numerics.Generic_Complex_Types (<>); package Ada.Text_IO.Complex_IO with Global => in out synchronized is

!ASIS

No ASIS effect.

!ACATS Test

Unclear whether detailed testing is worthwhile, but some C-Tests that show that language-defined packages work in parallel operations when the default conflict checking policy is in effect would be valuable.

!appendix


From: Tucker Taft
Sent: Tuesday, January 08, 2019 10:16 PM

Here is a first attempt to indicate how we will specify the Global aspect of
language-defined units. [This is version /01 of the AI - Editor.]

No wording yet.

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

Summary of private mail between Tucker Taft, Randy Brukardt, and Steve Baird:

Steve:

I was only objecting to the statement in the !problem section
   This is not consistent with the requirement of RM A(3/5) that
   language-defined (generic) packages be reentrant.

I don't see the inconsistency. I'm all in favor of this AI - I think there are
very good arguments for it - but I don't buy the argument given in the !problem
section.

Specifically:

A(3/5) is talking about a dynamic property:
    ... concurrent calls on any two (possibly the same) language-defined
    subprograms perform as specified, so long as ...

I view this as a 100% dynamic semantics rule that is unaffected by what is
specified for the Globals aspect of the subprograms in question; that (IMO)
makes it tough to use this rule as justification for this AI.

I certainly agree with the goal of this AI: we want to specify Globals aspects
as precisely as possible in order to avoid disallowing things that don't need to
be disallowed (and, perhaps for some compilers or tools, flagging thing that
don't need to be flagged).

Randy: > I suspect I might have forgotten about certain cases where we need
> to include  "& <formal_type>'Global".

I would guess that would be all of them. ;-) I've been assuming that generic
units include all of their formal parameters in the Global for the package;
individual operations could be more specific, but that's just too much work. The
exception would be formal scalar types (which by definition cannot be blocking
or use any globals).

This AI needs to check all of the formals, because the editor doesn't want to
do it alone.

Randy: AI12-0112-1 handles all of the containers, including individual
operations in many cases, so this AI doesn't need to mention them (other than
that info).

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

From: Tucker Taft
Sent: Tuesday, October 1, 2019  3:31 PM

Here is an update to the AI defining the Global aspect for language-defined
units.  It incorporates the new "overriding" notion of the latest AI12-0240-6,
and tries to address the issue of generic units more completely.

[This is version /03 of the AI - Editor.]

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

From: Randy Brukardt
Sent: Tuesday, October 1, 2019  7:03 PM

You're still missing the note that AI12-0112-1 handles all of the container's
Globals, including more specific ones when possible. You wouldn't want to list
out all of the possibilities I came up with! - there's "null" (for pure
navigation functions), the default of the package, "access <container type>",
some with specific formal parameters, and some combinations.

The fact that this is not handled in this AI needs to be mentioned in this AI.

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

From: Randy Brukardt
Sent: Tuesday, October 1, 2019  7:05 PM

I don't think you addressed Steve's concerns, either (see the "summary of
private mail" toward the end of the !appendix).

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

Questions? Ask the ACAA Technical Agent