!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)
or
    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)

@drepl
@xcode<@b<package> Ada.Tags @b<is>
    @b<pragma> Preelaborate(Tags);
    @b<type> Tag @b<is private>;
    @b<pragma> Preelaborable_Initialization(Tag);>
@dby
@xcode<@b<package> Ada.Tags
    @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>
    @b<type> Tag @b<is private>;
    @b<pragma> Preelaborable_Initialization(Tag);>

!corrigendum 3.9(18.2/3)

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


!corrigendum 9.6(10)

@drepl
@xcode<
@b<package> Ada.Calendar @b<is>
  @b<type> Time @b<is private>;>
@dby
@xcode<
@b<package> Ada.Calendar 
  @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>
  @b<type> Time @b<is private>;>

!corrigendum 9.6.1(2/2)

@drepl
@xcode<@b<package> Ada.Calendar.Time_Zones @b<is>>
@dby
@xcode<@b<package> Ada.Calendar.Time_Zones
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum 9.6.1(8/2)

@drepl
@xcode<
@b<package> Ada.Calendar.Arithmetic @b<is>>
@dby
@xcode<
@b<package> Ada.Calendar.Arithmetic
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum 9.6.1(15/2)

@drepl
@xcode<
@b<with> Ada.Calendar.Time_Zones;
@b<package> Ada.Calendar.Formatting @b<is>>
@dby
@xcode<
@b<with> Ada.Calendar.Time_Zones;
@b<package> Ada.Calendar.Formatting
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum 11.4.1(2/2)

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


!corrigendum 13.7.2(2)

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

!corrigendum 13.11.2(3/3)

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

!corrigendum 13.11.4(3/3)

@drepl
@xcode<@b<package> System.Storage_Pools.Subpools @b<is>
   @b<pragma> Preelaborate (Subpools);>
@dby
@xcode<@b<package> System.Storage_Pools.Subpools
   @b<with> Preelaborate, Global =@> @b<in out synchronized> @b<is>>

!corrigendum 13.11.4(10/3)

@drepl
@xcode<   @b<procedure> Set_Pool_of_Subpool (
      Subpool : @b<in not null> Subpool_Handle;
      To : @b<in out> Root_Storage_Pool_With_Subpools'Class);>
@dby
@xcode<   @b<procedure> Set_Pool_of_Subpool (
      Subpool : @b<in not null> Subpool_Handle;
      To : @b<in out> Root_Storage_Pool_With_Subpools'Class)
        @b<with> Global =@> @b<overriding in out> Subpool;>

!corrigendum 13.11.4(11/3)

@drepl
@xcode<   @b<procedure> Allocate_From_Subpool (
      Pool : @b<in out> Root_Storage_Pool_With_Subpools;
      Storage_Address : @b<out> Address;
      Size_In_Storage_Elements : @b<in> Storage_Elements.Storage_Count;
      Alignment : @b<in> Storage_Elements.Storage_Count;
      Subpool : @b<in not null> Subpool_Handle) @b<is abstract>
         @b<with> Pre'Class =@> Pool_of_Subpool(Subpool) = Pool'Access;>
@dby
@xcode<   @b<procedure> Allocate_From_Subpool (
      Pool : @b<in out> Root_Storage_Pool_With_Subpools;
      Storage_Address : @b<out> Address;
      Size_In_Storage_Elements : @b<in> Storage_Elements.Storage_Count;
      Alignment : @b<in> Storage_Elements.Storage_Count;
      Subpool : @b<in not null> Subpool_Handle) @b<is abstract>
         @b<with> Pre'Class =@> Pool_of_Subpool(Subpool) = Pool'Access,
              Global =@> @b<overriding in out> Subpool;>

!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)

@dinsa
The Write operation appends Item to the specified stream.
@dinss
See the conflict file for the text.



!corrigendum A.4.3(5)

@drepl
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Fixed @b<is>
   @b<pragma> Preelaborate(Fixed);>
@dby
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Fixed
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.4.4(3)

@drepl
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Bounded @b<is>
   @b<pragma> Preelaborate(Bounded);>
@dby
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Bounded
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.4.5(3)

@drepl
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Unbounded @b<is>
   @b<pragma> Preelaborate(Unbounded);>
@dby
@xcode<@b<with> Ada.Strings.Maps;
@b<package> Ada.Strings.Unbounded
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.4.7(3)

@drepl
@xcode<@b<package> Ada.Strings.Wide_Maps @b<is>
   @b<pragma> Preelaborate(Wide_Maps);>
@dby
@xcode<@b<package> Ada.Strings.Wide_Maps
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.4.7(46.2/2)

@drepl
@fa<Pragma> Pure is replaced by pragma Preelaborate in Strings.Wide_Maps.Wide_Constants.
@dby
@fa<Pragma> Pure is replaced by aspects @fc<@b<with> Preelaborate, Nonblocking,
Global =@> @b<in out synchronized>> in Strings.Wide_Maps.Wide_Constants.

!corrigendum A.4.8(3/2)

@drepl
@xcode<@b<package> Ada.Strings.Wide_Wide_Maps @b<is>
   @b<pragma> Preelaborate(Wide_Wide_Maps);>
@dby
@xcode<@b<package> Ada.Strings.Wide_Wide_Maps
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.4.8(50/2)

@drepl
@fa<Pragma> Pure is replaced by pragma Preelaborate in Strings.Wide_Maps.Wide_Constants.
@dby
@fa<Pragma> Pure is replaced by aspects @fc<@b<with> Preelaborate, Nonblocking,
Global =@> @b<in out synchronized>> in Strings.Wide_Wide_Maps.Wide_Wide_Constants.

!corrigendum A.4.9(7/3)

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

!corrigendum A.4.9(10/3)

@drepl
@xcode<@b<with> Ada.Containers;
@b<function> Ada.Strings.Unbounded.Hash (Key : Unbounded_String)
   @b<return> Containers.Hash_Type;
@b<pragma> Preelaborate(Ada.Strings.Unbounded.Hash);>
@dby
@xcode<@b<with> Ada.Containers;
@b<function> Ada.Strings.Unbounded.Hash (Key : Unbounded_String)
   @b<return> Containers.Hash_Type
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized>;>

!corrigendum A.4.9(11.7/3)

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

!corrigendum A.4.9(11.10/3)

@drepl
@xcode<@b<with> Ada.Containers;
@b<function> Ada.Strings.Unbounded.Hash_Case_Insensitive
   (Key : Unbounded_String) @b<return> Containers.Hash_Type;
@b<pragma> Preelaborate(Ada.Strings.Unbounded.Hash_Case_Insensitive);>
@dby
@xcode<@b<with> Ada.Containers;
@b<function> Ada.Strings.Unbounded.Hash_Case_Insensitive
   (Key : Unbounded_String) @b<return> Containers.Hash_Type
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized>;>

!corrigendum A.4.10(7/3)

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

!corrigendum A.4.10(10/3)

@drepl
@xcode<@b<function> Ada.Strings.Unbounded.Equal_Case_Insensitive
   (Left, Right : Unbounded_String) @b<return> Boolean;
@b<pragma> Preelaborate(Ada.Strings.Unbounded.Equal_Case_Insensitive);>
@dby
@xcode<@b<function> Ada.Strings.Unbounded.Equal_Case_Insensitive
   (Left, Right : Unbounded_String) @b<return> Boolean
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized>;>

!corrigendum A.4.10(18/3)

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

!corrigendum A.4.10(21/3)

@drepl
@xcode<@b<function> Ada.Strings.Unbounded.Less_Case_Insensitive
  (Left, Right : Unbounded_String) @b<return> Boolean;
@b<pragma> Preelaborate(Ada.Strings.Unbounded.Less_Case_Insensitive);>
@dby
@xcode<@b<function> Ada.Strings.Unbounded.Less_Case_Insensitive
  (Left, Right : Unbounded_String) @b<return> Boolean
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized>;>

!corrigendum A.5.2(5)

@drepl
@xcode<@b<package> Ada.Numerics.Float_Random @b<is>>
@dby
@xcode<@b<package> Ada.Numerics.Float_Random
   @b<with> Global =@> @b<in out synchronized> @b<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)

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

!corrigendum A.5.2(20)

@drepl
@xcode<   @b<function> Random (Gen : Generator) @b<return> Result_Subtype;>
@dby
@xcode<   @b<function> Random (Gen : Generator) @b<return> Result_Subtype
      @b<with> Global =@> @b<overriding in out> Gen;>

@xcode<   @b<function> Random (Gen   : Generator;
                    First : Result_Subtype;
                    Last  : Result_Subtype) @b<return> Result_Subtype
      @b<with> Post =@> Random'Result @b<in> First .. Last,
           Global =@> @b<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)

@dinsc
See the conflict file for the changes.

!corrigendum A.5.7(0)

@dinsc
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)

@drepl
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0);
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0);>
@dby
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(55)

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

!corrigendum A.10.1(59)

@drepl
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0);
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0);>
@dby
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(60)

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

!corrigendum A.10.1(65)

@drepl
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0);
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0);>
@dby
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(66)

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

!corrigendum A.10.1(70)

@drepl
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0);
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0);>
@dby
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(71)

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

!corrigendum A.10.1(75)

@drepl
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0);
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0);>
@dby
@xcode<      @b<procedure> Get(File  : @b<in>  File_Type;
                    Item  : @b<out> Num;
                    Width : @b<in> Field := 0)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item  : @b<out> Num;
                    Width : @b<in>  Field := 0)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(76)

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

!corrigendum A.10.1(81)

@drepl
@xcode<      @b<procedure> Get(File : @b<in>  File_Type;
                    Item : @b<out> Enum);
      @b<procedure> Get(Item : @b<out> Enum);>
@dby
@xcode<      @b<procedure> Get(File : @b<in>  File_Type;
                    Item : @b<out> Enum)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Get(Item : @b<out> Enum)
         @b<with> Global =@> @b<in out all>;>

!corrigendum A.10.1(82)

@drepl
@xcode<      @b<procedure> Put(File  : @b<in> File_Type;
                    Item  : @b<in> Enum;
                    Width : @b<in> Field    := Default_Width;
                    Set   : @b<in> Type_Set := Default_Setting);
      @b<procedure> Put(Item  : @b<in> Enum;
                    Width : @b<in> Field    := Default_Width;
                    Set   : @b<in> Type_Set := Default_Setting);>
@dby
@xcode<      @b<procedure> Put(File  : @b<in> File_Type;
                    Item  : @b<in> Enum;
                    Width : @b<in> Field    := Default_Width;
                    Set   : @b<in> Type_Set := Default_Setting)
         @b<with> Global =@> @b<overriding in out> File;
      @b<procedure> Put(Item  : @b<in> Enum;
                    Width : @b<in> Field    := Default_Width;
                    Set   : @b<in> Type_Set := Default_Setting)
         @b<with> Global =@> @b<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)

@drepl
@xcode<@b<package> Ada.Command_Line @b<is>
   @b<pragma> Preelaborate(Command_Line);>
@dby
@xcode<@b<package> Ada.Command_Line
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum A.16(3/2)

@drepl
@xcode<@b<with> Ada.IO_Exceptions;
@b<with> Ada.Calendar;
@b<package> Ada.Directories @b<is>>
@dby
@xcode<@b<with> Ada.IO_Exceptions;
@b<with> Ada.Calendar;
@b<package> Ada.Directories
   @b<with> Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.16.1(3/3)

@drepl
@xcode<@b<package> Ada.Directories.Hierarchical_File_Names @b<is>>
@dby
@xcode<@b<package> Ada.Directories.Hierarchical_File_Names
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum A.17(3/2)

@drepl
@xcode<@b<package> Ada.Environment_Variables @b<is>
   @b<pragma> Preelaborate(Environment_Variables);>
@dby
@xcode<@b<package> Ada.Environment_Variables
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>



!corrigendum B.3.1(3)

@drepl
@xcode<@b<package> Interfaces.C.Strings @b<is>
   @b<pragma> Preelaborate(Strings);>
@dby
@xcode<@b<package> Interfaces.C.Strings
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum B.3.2(4)

@drepl
@xcode<@b<generic>
   @b<type> Index @b<is> (<@>);
   @b<type> Element @b<is private>;
   @b<type> Element_Array @b<is array> (Index @b<range> <@>) @b<of aliased> Element;
   Default_Terminator : Element;
@b<package> Interfaces.C.Pointers @b<is>
   @b<pragma> Preelaborate(Pointers);>
@dby
@xcode<@b<generic>
   @b<type> Index @b<is> (<@>);
   @b<type> Element @b<is private>;
   @b<type> Element_Array @b<is array> (Index @b<range> <@>) @b<of aliased> Element;
   Default_Terminator : Element;
@b<package> Interfaces.C.Pointers
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum B.4(7)

@drepl
@xcode<@b<package> Interfaces.COBOL @b<is>
   @b<pragma> Preelaborate(COBOL);>
@dby
@xcode<@b<package> Interfaces.COBOL
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum C.3.2(2/3)

@drepl
@xcode<@b<with> System;
@b<with> System.Multiprocessors;
@b<package> Ada.Interrupts @b<is>
   @b<type> Interrupt_Id @b<is> @ft<@i<implementation-defined>>;
   @b<type> Parameterless_Handler @b<is>
      @b<access protected procedure>;>
@dby
@xcode<@b<with> System;
@b<with> System.Multiprocessors;
@b<package> Ada.Interrupts
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>
   @b<type> Interrupt_Id @b<is> @ft<@i<implementation-defined>>;
   @b<type> Parameterless_Handler @b<is>
      @b<access protected procedure>
      @b<with> Nonblocking =@> False;>

!corrigendum C.3.2(12)

@drepl
@xcode<@b<package> Ada.Interrupts.Names @b<is>
   @ft<@i<implementation-defined>> : @b<constant> Interrupt_Id :=
     @ft<@i<implementation-defined>>;
      . . .
   @ft<@i<implementation-defined>> : @b<constant> Interrupt_Id :=
     @ft<@i<implementation-defined>>;
@b<end> Ada.Interrupts.Names;>
@dby
@xcode<@b<package> Ada.Interrupts.Names 
   @b<with> Nonblocking, Global =@> @b<null> @b<is>
   @ft<@i<implementation-defined>> : @b<constant> Interrupt_Id :=
     @ft<@i<implementation-defined>>;
      . . .
   @ft<@i<implementation-defined>> : @b<constant> Interrupt_Id :=
     @ft<@i<implementation-defined>>;
@b<end> Ada.Interrupts.Names;>

!corrigendum C.7.1(2/2)

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

!corrigendum C.7.2(2)

@drepl
@xcode<@b<with> Ada.Task_Identification; @b<use> Ada.Task_Identification;
@b<generic>
   @b<type> Attribute @b<is private>;
   Initial_Value : @b<in> Attribute;
@b<package> Ada.Task_Attributes @b<is>>
@dby
@xcode<@b<with> Ada.Task_Identification; @b<use> Ada.Task_Identification;
@b<generic>
   @b<type> Attribute @b<is private>;
   Initial_Value : @b<in> Attribute;
@b<package> Ada.Task_Attributes
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum C.7.3(2/2)

@drepl
@xcode<@b<with> Ada.Task_Identification;
@b<with> Ada.Exceptions;
@b<package> Ada.Task_Termination @b<is>
   @b<pragma> Preelaborate(Task_Termination);>
@dby
@xcode<@b<with> Ada.Task_Identification;
@b<with> Ada.Exceptions;
@b<package> Ada.Task_Termination
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum D.2.1(1.2/3)

@drepl
@xcode<@b<package> Ada.Dispatching @b<is>
  @b<pragma> Preelaborate(Dispatching);>
@dby
@xcode<@b<package> Ada.Dispatching
  @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.2.4(2.2/3)

@drepl
@xcode<@b<package> Ada.Dispatching.Non_Preemptive @b<is>
   @b<pragma> Preelaborate(Non_Preemptive);
   @b<procedure> Yield_To_Higher;
   @b<procedure> Yield_To_Same_Or_Higher @b<renames> Yield;
@b<end> Ada.Dispatching.Non_Preemptive;>
@dby
@xcode<@b<package> Ada.Dispatching.Non_Preemptive
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>
   @b<procedure> Yield_To_Higher;
   @b<procedure> Yield_To_Same_Or_Higher @b<renames> Yield;
@b<end> Ada.Dispatching.Non_Preemptive;>

!corrigendum D.2.5(4/2)

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

!corrigendum D.2.6(9/2)

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


!corrigendum D.5.1(3/2)

@drepl
@xcode<@b<with> System;
@b<with> Ada.Task_Identification; @ft<@i<-- See C.7.1>>
@b<package> Ada.Dynamic_Priorities @b<is>
    @b<pragma> Preelaborate(Dynamic_Priorities);>
@dby
@xcode<@b<with> System;
@b<with> Ada.Task_Identification; @ft<@i<-- See C.7.1>>
@b<package> Ada.Dynamic_Priorities
    @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.8(3)

@drepl
@xcode<@b<package> Ada.Real_Time @b<is>>
@dby
@xcode<@b<package> Ada.Real_Time 
  @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum D.10(3/2)

@drepl
@xcode<@b<package> Ada.Synchronous_Task_Control @b<is>
   @b<pragma> Preelaborate(Synchronous_Task_Control);>
@dby
@xcode<@b<package> Ada.Synchronous_Task_Control
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.10(5.2/3)

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

!corrigendum D.10.1(3/3)

@drepl
@xcode<@b<package> Ada.Synchronous_Barriers @b<is>
   @b<pragma> Preelaborate(Synchronous_Barriers);>
@dby
@xcode<@b<package> Ada.Synchronous_Barriers
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.11(3/2)

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

!corrigendum D.14(3/2)

@drepl
@xcode<@b<with> Ada.Task_Identification;
@b<with> Ada.Real_Time; @b<use> Ada.Real_Time;
@b<package> Ada.Execution_Time @b<is>>
@dby
@xcode<@b<with> Ada.Task_Identification;
@b<with> Ada.Real_Time; @b<use> Ada.Real_Time;
@b<package> Ada.Execution_Time
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.14.1(3/2)

@drepl
@xcode<@b<with> System;
@b<package> Ada.Execution_Time.Timers @b<is>>
@dby
@xcode<@b<with> System;
@b<package> Ada.Execution_Time.Timers
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.14.2(3/3)

@drepl
@xcode<@b<with> System;
@b<with> System.Multiprocessors;
@b<package> Ada.Execution_Time.Group_Budgets @b<is>>
@dby
@xcode<@b<with> System;
@b<with> System.Multiprocessors;
@b<package> Ada.Execution_Time.Group_Budgets
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.14.3(3/3)

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

!corrigendum D.15(3/2)

@drepl
@xcode<@b<package> Ada.Real_Time.Timing_Events @b<is>>
@dby
@xcode<@b<package> Ada.Real_Time.Timing_Events
  @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.16(3/3)

@drepl
@xcode<@b<package> System.Multiprocessors @b<is>
   @b<pragma> Preelaborate(Multiprocessors);>
@dby
@xcode<@b<package> System.Multiprocessors
   @b<with> Preelaborate, Nonblocking, Global =@> @b<in out synchronized> @b<is>>

!corrigendum D.16.1(3/3)

@drepl
@xcode<@b<with> Ada.Real_Time;
@b<with> Ada.Task_Identification;
@b<package> System.Multiprocessors.Dispatching_Domains @b<is>>
@dby
@xcode<@b<with> Ada.Real_Time;
@b<with> Ada.Task_Identification;
@b<package> System.Multiprocessors.Dispatching_Domains
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum E.5(3)

@drepl
@xcode<@b<with> Ada.Streams; -- @ft<@i<see 13.13.1>>
@b<package> System.RPC @b<is>>
@dby
@xcode<@b<with> Ada.Streams; -- @ft<@i<see 13.13.1>>
@b<package> System.RPC
   @b<with> Nonblocking =@> False, Global =@> @b<in out synchronized> @b<is>>


!corrigendum F.3.3(3)

@drepl
@xcode<@b<package> Ada.Text_IO.Editing @b<is>>
@dby
@xcode<@b<package> Ada.Text_IO.Editing
   @b<with> Nonblocking, Global =@> @b<in out synchronized> @b<is>>


!corrigendum G.1.3(3)

@drepl
@xcode<@b<with> Ada.Numerics.Generic_Complex_Types;
@b<generic>
   @b<with package> Complex_Types @b<is>
         @b<new> Ada.Numerics.Generic_Complex_Types (<@>);
@b<package> Ada.Text_IO.Complex_IO @b<is>>
@dby
@xcode<@b<with> Ada.Numerics.Generic_Complex_Types;
@b<generic>
   @b<with package> Complex_Types @b<is>
         @b<new> Ada.Numerics.Generic_Complex_Types (<@>);
@b<package> Ada.Text_IO.Complex_IO
   @b<with> Global =@> @b<in out synchronized> @b<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).

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