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

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

--- ai12s/ai12-0241-1.txt	2017/12/15 00:40:51	1.1
+++ ai12s/ai12-0241-1.txt	2017/12/20 02:59:27	1.2
@@ -1,7 +1,92 @@
-!standard 9.6.1(2/3)                                  17-12-14  AI12-0241-1/00
-!standard 9.6.1(5/4)
-!standard 9.6.1(7/3)
+!standard 3.9(6/2)                                   17-12-19  AI12-0241-1/01
+!standard 3.9(18.2/3)
+!standard 5.5.1(2/3)
+!standard 7.6(4/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.9(3/3)
+!standard 13.11.2(3/3)
+!standard 13.13.1(2)
+!standard A.4.3(5)
+!standard A.4.4(3)
+!standard A.4.5(3)
+!standard A.4.7(3)
+!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.1(3)
+!standard A.10.1(55)
+!standard A.10.1(60)
+!standard A.10.1(67)
+!standard A.10.1(72)
+!standard A.10.1(77)
+!standard A.10.1(83)
+!standard A.15(3)
+!standard A.16(15/2)
+!standard A.16(16/2)
+!standard A.16(17/2)
+!standard A.16(18/2)
+!standard A.16(19/2)
+!standard A.16(20/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.7.1(2/2)
+!standard C.7.1(3/3)
+!standard C.7.1(16)
+!standard C.7.2(2)
+!standard C.7.3(2/2)
+!standard D.2.1(1.2/3)
+!standard D.2.1(1.3/3)
+!standard D.2.1(7/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(4)
+!standard D.10(5.2/3)
+!standard D.10(10)
+!standard D.10(10.1/3)
+!standard D.10.1(3/3)
+!standard D.10.1(6/3)
+!standard D.10.1(14/3)
+!standard D.11(3/2)
+!standard D.14(3/2)
+!standard D.14.1(3/2)
+!standard D.14.1(5/2)
+!standard D.14.2(3/2)
+!standard D.14.2(5/2)
+!standard D.14.3(3/3)
+!standard D.15(3/2)
+!standard D.15(4/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 F.3.3(14)
+!standard F.3.3(15)
+!standard G.1.1(2/1)
+!standard G.1.2(2/2)
+!standard G.1.3(8)
+!standard G.3.1(2/2)
+!standard G.3.2(2/2)
 !class Amendment 17-12-14
+!status Amendment 1-2012 17-12-18
 !status work item 17-12-14
 !status received 17-12-14
 !priority Low
@@ -25,8 +110,688 @@
 
 !wording
 
-** TBD.
+Replace 3.9(6/2) by:
 
+package Ada.Tags
+    with Preelaborate, Nonblocking is
+    type Tag is private;
+    pragma Preelaborable_Initialization(Tag);
+
+Replace 3.9(18.2/3) 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 => Constructor'Nonblocking;
+
+Replace 5.5.1(2/3) by:
+
+generic
+   type Cursor;
+   with function Has_Element (Position : Cursor) return Boolean;
+package Ada.Iterator_Interfaces
+   with Pure, Nonblocking => False is
+
+Replace 7.6(4/3) by:
+
+package Ada.Finalization
+   with Pure, Nonblocking => False is
+
+Replace 9.6(10) by:
+
+package Ada.Calendar with Nonblocking is
+  type Time is private;
+
+Replace 9.6.1(2/2) by:
+
+package Ada.Calendar.Time_Zones
+   with Nonblocking is
+
+Replace 9.6.1(8/2) by:
+
+package Ada.Calendar.Arithmetic
+   with Nonblocking is
+
+Replace 9.6.1(15/2) by:
+
+with Ada.Calendar.Time_Zones;
+package Ada.Calendar.Formatting
+   with Nonblocking is
+
+Replace 11.4.1(2/2) by:
+
+with Ada.Streams;
+package Ada.Exceptions
+    with Preelaborate, Nonblocking 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;
+
+Replace 13.7.2(2) by:
+
+generic
+    type Object(<>) is limited private;
+package System.Address_To_Access_Conversions
+   with Preelaborate, Nonblocking is
+
+Replace 13.9(3/3) by:
+
+generic
+   type Source(<>) is limited private;
+   type Target(<>) is limited private;
+function Ada.Unchecked_Conversion(S : Source) return Target
+   with Pure, Nonblocking, Convention => Intrinsic;
+
+Replace 13.11.2(3/3) 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;
+
+Replace 13.13.1(2) by:
+
+package Ada.Streams is
+   with Pure, Nonblocking => False is
+
+Replace A.4.3(5) by:
+
+with Ada.Strings.Maps;
+package Ada.Strings.Fixed
+   with Preelaborate, Nonblocking is
+
+Replace A.4.4(3) by:
+
+with Ada.Strings.Maps;
+package Ada.Strings.Bounded
+   with Preelaborate, Nonblocking is
+
+Replace A.4.5(3) by:
+
+with Ada.Strings.Maps;
+package Ada.Strings.Unbounded
+   with Preelaborate, Nonblocking is
+
+Replace A.4.7(3) by:
+
+package Ada.Strings.Wide_Maps
+   with Preelaborate, Nonblocking is
+
+Replace A.4.9(7/3) 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;
+
+Replace A.4.9(10/3) by:
+
+with Ada.Containers;
+function Ada.Strings.Unbounded.Hash (Key : Unbounded_String)
+   return Containers.Hash_Type
+   with Preelaborate, Nonblocking;
+
+Replace A.4.9(11.7/3) 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;
+
+Replace A.4.9(11.10/3) by:
+
+with Ada.Containers;
+function Ada.Strings.Unbounded.Hash_Case_Insensitive
+   (Key : Unbounded_String) return Containers.Hash_Type;
+   with Preelaborate, Nonblocking;
+
+Replace A.4.10(7/3) 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;
+
+Replace A.4.10(10/3) by:
+
+function Ada.Strings.Unbounded.Equal_Case_Insensitive
+   (Left, Right : Unbounded_String) return Boolean
+   with Preelaborate, Nonblocking;
+
+Replace A.4.10(18/3) 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;
+
+Replace A.4.10(21/3) by:
+
+function Ada.Strings.Unbounded.Less_Case_Insensitive
+  (Left, Right : Unbounded_String) return Boolean
+   with Preelaborate, Nonblocking;
+
+Replace A.5.1(3) by:
+
+generic
+   type Float_Type is digits <>;
+
+package Ada.Numerics.Generic_Elementary_Functions
+   with Pure, Nonblocking;
+
+Replace A.10.1(55) by:
+
+      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)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in Num;
+                    Base : in Number_Base := Default_Base)
+         with Nonblocking;
+
+Replace A.10.1(60) by:
+
+      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)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in Num;
+                    Base : in Number_Base := Default_Base)
+         with Nonblocking;
+
+Replace A.10.1(67) by:
+
+      procedure Get(From : in  String;
+                    Item : out Num;
+                    Last : out Positive)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in Num;
+                    Aft  : in Field := Default_Aft;
+                    Exp  : in Field := Default_Exp)
+         with Nonblocking;
+   end Float_IO;
+
+Replace A.10.1(72) by:
+
+      procedure Get(From : in  String;
+                    Item : out Num;
+                    Last : out Positive)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in Num;
+                    Aft  : in Field := Default_Aft;
+                    Exp  : in Field := Default_Exp)
+         with Nonblocking;
+   end Fixed_IO;
+
+Replace A.10.1(77) by:
+
+      procedure Get(From : in  String;
+                    Item : out Num;
+                    Last : out Positive)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in Num;
+                    Aft  : in Field := Default_Aft;
+                    Exp  : in Field := Default_Exp)
+         with Nonblocking;
+   end Decimal_IO;
+
+Replace A.10.1(83) by:
+
+      procedure Get(From : in  String;
+                    Item : out Enum;
+                    Last : out Positive)
+         with Nonblocking;
+      procedure Put(To   : out String;
+                    Item : in  Enum;
+                    Set  : in  Type_Set := Default_Setting)
+         with Nonblocking;
+   end Enumeration_IO;
+
+Replace A.15(3) by:
+
+package Ada.Command_Line
+   with Preelaborate, Nonblocking is
+
+Replace A.16(15/2) by:
+
+function Full_Name (Name : in String) return String
+   with Nonblocking;
+
+Replace A.16(16/2) by:
+
+function Simple_Name (Name : in String) return String
+   with Nonblocking;
+
+Replace A.16(17/2) by:
+
+function Containing_Directory (Name : in String) return String
+   with Nonblocking;
+
+Replace A.16(18/2) by:
+
+function Extension (Name : in String) return String
+   with Nonblocking;
+
+Replace A.16(19/2) by:
+
+function Base_Name (Name : in String) return String
+   with Nonblocking;
+
+Replace A.16(20/2) by:
+
+function Compose (Containing_Directory : in String := "";
+                  Name                 : in String;
+                  Extension            : in String := "") return String
+   with Nonblocking;
+
+Replace A.16.1(3/3) by:
+
+package Ada.Directories.Hierarchical_File_Names
+   with Nonblocking is
+
+Replace A.17(3/2) by:
+
+package Ada.Environment_Variables
+   with Preelaborate, Nonblocking is
+
+Replace B.3.1(3) by:
+
+package Interfaces.C.Strings
+   with Preelaborate, Nonblocking is
+
+Replace B.3.2(4) by:
+
+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
+   with Preelaborate, Nonblocking;
+
+Replace B.4(7) by:
+
+package Interfaces.COBOL
+   with Preelaborate, Nonblocking is
+
+Replace C.3.2(2/3) by:
+
+with System;
+with System.Multiprocessors;
+package Ada.Interrupts
+   with Nonblocking is
+   type Interrupt_Id is implementation-defined;
+   type Parameterless_Handler is
+      access protected procedure
+      with Nonblocking => False;
+
+Replace C.7.1(2/2) by:
+
+package Ada.Task_Identification
+   with Preelaborate, Nonblocking is
+   type Task_Id is private;
+   pragma Preelaborable_Initialization (Task_Id);
+   Null_Task_Id : constant Task_Id;
+   function  "=" (Left, Right : Task_Id) return Boolean;
+
+Replace C.7.1(3/3) by:
+
+   function  Image                  (T : Task_Id) return String;
+   function  Current_Task     return Task_Id;
+   function  Environment_Task return Task_Id;
+   procedure Abort_Task             (T : in Task_Id)
+      with Nonblocking => False;
+
+Delete C.7.1(16).
+
+Replace C.7.2(2) by:
+
+with Ada.Task_Identification; use Ada.Task_Identification;
+generic
+   type Attribute is private;
+   Initial_Value : in Attribute;
+package Ada.Task_Attributes
+   with Nonblocking is
+
+Replace C.7.3(2/2) by:
+
+with Ada.Task_Identification;
+with Ada.Exceptions;
+package Ada.Task_Termination
+   with Preelaborate, Nonblocking is
+
+Replace D.2.1(1.2/3) by:
+
+package Ada.Dispatching
+   with Preelaborate, Nonblocking is
+
+Replace D.2.1(1.3/3) by:
+
+    procedure Yield
+       with Nonblocking => False;
+
+Replace D.2.1(7/3) by:
+
+A call of Yield is a task dispatching point.
+
+Replace D.2.4(2.2/3) by:
+
+package Ada.Dispatching.Non_Preemptive
+  with Preelaborate, Nonblocking is
+  procedure Yield_To_Higher;
+  procedure Yield_To_Same_Or_Higher renames Yield;
+end Ada.Dispatching.Non_Preemptive;
+
+Replace D.2.5(4/2) by:
+
+with System;
+with Ada.Real_Time;
+package Ada.Dispatching.Round_Robin
+  with Nonblocking 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;
+
+Replace D.2.6(9/2) by:
+
+with Ada.Real_Time;
+with Ada.Task_Identification;
+package Ada.Dispatching.EDF
+  with Nonblocking 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;
+
+[Editor's note: The previous wording for Delay_Until_And_Set_Deadline being
+potentially blocking was missing, but it has to be the case, as this is an
+analog with a delay until statement (which is potentially blocking). This was
+verified with Alan Burns. This is the only intended semantic change by this
+AI; everything else is replacing wording with explicit declarations.]
+
+Replace D.5.1(3/2) by:
+
+with System;
+with Ada.Task_Identification; -- See C.7.1
+package Ada.Dynamic_Priorities
+    with Preelaborate, Nonblocking is
+
+Replace D.8(3) by:
+
+package Ada.Real_Time
+  with Nonblocking is
+
+Replace D.10(3/2) by:
+
+package Ada.Synchronous_Task_Control
+   with Preelaborate, Nonblocking is
+
+Replace D.10(4) by:
+
+type Suspension_Object is limited private;
+  procedure Set_True(S : in out Suspension_Object);
+  procedure Set_False(S : in out Suspension_Object);
+  function Current_State(S : Suspension_Object) return Boolean;
+  procedure Suspend_Until_True(S : in out Suspension_Object)
+     with Nonblocking => False;
+private
+     ... -- not specified by the language
+end Ada.Synchronous_Task_Control;
+
+Replace D.10(5.2/3) by:
+
+package Ada.Synchronous_Task_Control.EDF
+   with Nonblocking 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;
+
+Replace D.10(10) by:
+
+Program_Error is raised upon calling Suspend_Until_True if another task is
+already waiting on that suspension object.
+
+Replace D.10(10.1/3) by:
+
+The procedure Suspend_Until_True_And_Set_Deadline blocks the calling task
+until the state of the object S is True; at that point the task becomes
+ready with a deadline of Ada.Real_Time.Clock + TS, and the state of the
+object becomes False. Program_Error is raised upon calling
+Suspend_Until_True_And_Set_Deadline if another task is already waiting on
+that suspension object.
+
+Replace D.10.1(3/3) by:
+
+package Ada.Synchronous_Barriers
+   with Preelaborate, Nonblocking is
+
+Replace D.10.1(6/3) by:
+
+   procedure Wait_For_Release (The_Barrier : in out Synchronous_Barrier;
+                               Notified    :    out Boolean)
+      with Nonblocking => False;
+
+Delete D.10.1(14/3).
+
+Replace D.11(3/2) by:
+
+with Ada.Task_Identification;
+package Ada.Asynchronous_Task_Control
+  with Preelaborate, Nonblocking 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;
+
+Replace D.14(3/2) by:
+
+with Ada.Task_Identification;
+with Ada.Real_Time; use Ada.Real_Time;
+package Ada.Execution_Time
+   with Nonblocking is
+
+Replace D.14.1(3/2) by:
+
+with System;
+package Ada.Execution_Time.Timers
+   with Nonblocking is
+
+Replace D.14.1(5/2) by:
+
+   type Timer_Handler is
+      access protected procedure (TM : in out Timer)
+      with Nonblocking => False;
+
+Replace D.14.2(3/3) by:
+
+with System;
+with System.Multiprocessors;
+package Ada.Execution_Time.Group_Budgets
+   with Nonblocking is
+
+Replace D.14.2(5/2) by:
+
+   type Group_Budget_Handler is access
+       protected procedure (GB : in out Group_Budget)
+       with Nonblocking => False;
+
+Replace D.14.3(3/3) by:
+
+with Ada.Interrupts;
+package Ada.Execution_Time.Interrupts
+   with Nonblocking 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;
+
+Replace D.15(3/2) by:
+
+package Ada.Real_Time.Timing_Events
+   with Nonblocking is
+
+Replace D.15(4/2) by:
+
+  type Timing_Event is tagged limited private;
+  type Timing_Event_Handler
+       is access protected procedure (Event : in out Timing_Event)
+       with Nonblocking => False;
+
+Replace D.16(3/3) by:
+
+package System.Multiprocessors
+   with Preelaborate, Nonblocking is
+
+Replace D.16.1(3/3) by:
+
+with Ada.Real_Time;
+with Ada.Task_Identification;
+package System.Multiprocessors.Dispatching_Domains
+   with Nonblocking is
+
+Replace E.5(3) by:
+
+with Ada.Streams; -- see 13.13.1
+package System.RPC
+   with Nonblocking => False is
+
+Delete E.5(23).
+
+Replace F.3.3(3) by:
+
+package Ada.Text_IO.Editing
+   with Nonblocking is
+
+Replace F.3.3(14) by:
+
+      procedure Put (File       : in File_Type;
+                     Item       : in Num;
+                     Pic        : in Picture;
+                     Currency   : in String    := Default_Currency;
+                     Fill       : in Character := Default_Fill;
+                     Separator  : in Character := Default_Separator;
+                     Radix_Mark : in Character := Default_Radix_Mark)
+          with Nonblocking => False;
+
+Replace F.3.3(15) by:
+
+      procedure Put (Item       : in Num;
+                     Pic        : in Picture;
+                     Currency   : in String    := Default_Currency;
+                     Fill       : in Character := Default_Fill;
+                     Separator  : in Character := Default_Separator;
+                     Radix_Mark : in Character := Default_Radix_Mark)
+           with Nonblocking => False;
+
+Replace G.1.1(2/1) by:
+
+generic
+   type Real is digits <>;
+package Ada.Numerics.Generic_Complex_Types
+   with Pure, Nonblocking is
+
+Replace G.1.2(2/2) by:
+
+with Ada.Numerics.Generic_Complex_Types;
+generic
+   with package Complex_Types is
+         new Ada.Numerics.Generic_Complex_Types (<>);
+   use Complex_Types;
+package Ada.Numerics.Generic_Complex_Elementary_Functions
+   with Pure, Nonblocking is
+
+Replace G.1.3(8) by:
+
+   procedure Get (From : in  String;
+                  Item : out Complex;
+                  Last : out Positive)
+      with Nonblocking;
+   procedure Put (To   : out String;
+                  Item : in  Complex;
+                  Aft  : in  Field := Default_Aft;
+                  Exp  : in  Field := Default_Exp)
+      with Nonblocking;
+
+Replace G.3.1(2/2) by:
+
+generic
+   type Real is digits <>;
+package Ada.Numerics.Generic_Real_Arrays
+   with Pure, Nonblocking is
+
+Replace G.3.2(2/2) by:
+
+with Ada.Numerics.Generic_Real_Arrays, Ada.Numerics.Generic_Complex_Types;
+generic
+   with package Real_Arrays   is new
+      Ada.Numerics.Generic_Real_Arrays   (<>);
+   use Real_Arrays;
+   with package Complex_Types is new
+      Ada.Numerics.Generic_Complex_Types (Real);
+   use Complex_Types;
+package Ada.Numerics.Generic_Complex_Arrays
+   with Pure, Nonblocking is
+
 !discussion
 
 This AI was split from the original AI12-0064-2 to keep the size of that AI
@@ -52,11 +817,9 @@
     package Ada.Command_Line
        with Preelaborate, Nonblocking is
 
-[Lengthy Editor's note:
-
 We intend that language-defined subprograms are nonblocking
 unless this Standard says otherwise. Specifically, 9.5.1(18) said (before we
-deleted it above):
+deleted it in AI12-0064-2):
 
   Certain language-defined subprograms are potentially blocking. In particular,
   the subprograms of the language-defined input-output packages that
@@ -67,7 +830,7 @@
 
 Non-generic units that are pure are automatically nonblocking as specified in
 9.5 (these are noted below). Other units should explicitly have aspect
-Nonblocking specified.
+Nonblocking specified if nonblocking is desired.
 
 We'll handle the containers in AI12-0112-1 (the AI that defines preconditions
 for the container operations); it probably makes the most sense to add all of
@@ -93,7 +856,7 @@
   Ada.Directories  A.16 - Nonblocking => False (I/O) - Full_Name through Compose should have Nonblocking => True (as they are just string manipulation routines).
   Ada.Directories.Hierarchical_File_Names  A.16.1 - Nonblocking => True (these are all string manipulation routines).
   Ada.Directories.Information  A.16 - (**** Impl def)
-  Ada.Dispatching  D.2.1 - Nonblocking => False (For Yield by the second sentence of D.2.1(7/3), which should be deleted. There are no other subprograms here.)
+  Ada.Dispatching  D.2.1 - Nonblocking => True (Yield has Nonblocking => False by the second sentence of D.2.1(7/3), which should be deleted.)
   Ada.Dispatching.EDF  D.2.6 - Nonblocking => True - Delay_Until_and_Set_Deadline has Nonblocking => False. -- (This wording is missing from the RM, 
                                                     -- so we don't have to delete it.) (***** AB.)
   Ada.Dispatching.Non_Preemptive  D.2.4 - Nonblocking => True -- AARM Note D.2.4(2.b/3) confirms this for Yield_to_Higher.
@@ -209,7 +972,7 @@
   Ada.Task_Termination  C.7.3 - Nonblocking => True
   Ada.Text_IO  A.10.1 - Nonblocking => False (** String routines)
   Ada.Text_IO.Bounded_IO  A.10.11 - Nonblocking => False -- I/O
-  Ada.Text_IO.Complex_IO  G.1.3 - Nonblocking => False -- I/O
+  Ada.Text_IO.Complex_IO  G.1.3 - Nonblocking => False (** String routines)
   Ada.Text_IO.Editing  F.3.3 - Nonblocking => False (** String routines)
   Ada.Text_IO.Text_Streams  A.12.2 - Nonblocking => False
   Ada.Text_IO.Unbounded_IO  A.10.12 - Nonblocking => False
@@ -249,6 +1012,8 @@
   System.Storage_Pools.Subpools  13.11.4 - Nonblocking => False (*** user overriding)
 
 Items marked "Pure" are pure, and thus automatically are Nonblocking.
+Items marked "Nonblocking => False" do not need an explicit aspect unless they
+are otherwise Pure.
 
 Items marked "(* generic)" have Nonblocking given as a formula. This
 automatically matches the nonblocking setting to that of the actual
@@ -285,8 +1050,1249 @@
 the semantics of a delay statement, needs to be potentially blocking but isn't
 declared this way in the RM.
 
-End lengthy editor's note.]
+!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 @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 =@> Constructor'Nonblocking;>
+
+!corrigendum 5.5.1(2/3)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Cursor;
+   @b<with function> Has_Element (Position : Cursor) @b<return> Boolean;
+@b<package> Ada.Iterator_Interfaces @b<is>
+   @b<pragma> Pure (Iterator_Interfaces);>
+@dby
+@xcode<@b<generic>
+   @b<type> Cursor;
+   @b<with function> Has_Element (Position : Cursor) @b<return> Boolean;
+@b<package> Ada.Iterator_Interfaces
+   @b<with> Pure, Nonblocking =@> False @b<is>>
+
+!corrigendum 7.6(4/3)
+
+@drepl
+@xcode<@b<package> Ada.Finalization @b<is>
+   @b<pragma> Pure;>
+@dby
+@xcode<@b<package> Ada.Finalization
+   @b<with> Pure, Nonblocking =@> False @b<is>>
+
+!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 @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 @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 @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 @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 @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 @b<is>>
+
+!corrigendum 13.9(3/3)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Source(<@>) @b<is limited private>;
+   @b<type> Target(<@>) @b<is limited private>;
+@b<function> Ada.Unchecked_Conversion(S : Source) @b<return> Target
+   @b<with> Convention =@> Intrinsic;
+@b<pragma> Pure(Ada.Unchecked_Conversion);>
+@dby
+@xcode<@b<generic>
+   @b<type> Source(<@>) @b<is limited private>;
+   @b<type> Target(<@>) @b<is limited private>;
+@b<function> Ada.Unchecked_Conversion(S : Source) @b<return> Target
+   @b<with> Pure, Nonblocking, Convention =@> Intrinsic;>
+
+!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;>
+
+!corrigendum 13.13.1(2)
+
+@drepl
+@xcode<@b<package> Ada.Streams @b<is>
+   @b<pragma> Pure(Streams);>
+@dby
+@xcode<@b<package> Ada.Streams
+   @b<with> Pure, Nonblocking =@> False @b<is>>
+
+!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 @b<is>>
+
+!corridendum 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 @b<is>>
+
+!corridendum 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 @b<is>>
+
+!corridendum 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 @b<is>>
+
+!corridendum 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 @b<is>>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!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;>
+
+!corrigendum A.5.1(3)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Float_Type @b<is digits> <@>;
+
+@b<package> Ada.Numerics.Generic_Elementary_Functions @b<is>
+   @b<pragma> Pure(Generic_Elementary_Functions);>
+@dby
+@xcode<@b<generic>
+   @b<type> Float_Type @b<is digits> <@>;
+
+@b<package> Ada.Numerics.Generic_Elementary_Functions
+   @b<with> Pure, Nonblocking @b<is>>
+
+!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<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<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(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<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<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(67)
+
+@drepl
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp);
+   @b<end> Float_IO;>
+@dby
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp)
+         @b<with> Nonblocking;
+   @b<end> Float_IO;>
+
+!corrigendum A.10.1(72)
+
+@drepl
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp);
+   @b<end> Fixed_IO;>
+@dby
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp)
+         @b<with> Nonblocking;
+   @b<end> Fixed_IO;>
+
+!corrigendum A.10.1(77)
+
+@drepl
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp);
+   @b<end> Decimal_IO;>
+
+@dby
+@xcode<      @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;
+                    Aft  : @b<in> Field := Default_Aft;
+                    Exp  : @b<in> Field := Default_Exp)
+         @b<with> Nonblocking;
+   @b<end> Decimal_IO;>
+
+!corrigendum A.10.1(83)
+
+@drepl
+@xcode<      @b<procedure> Get(From : @b<in>  String;
+                    Item : @b<out> Enum;
+                    Last : @b<out> Positive);
+      @b<procedure> Put(To   : @b<out> String;
+                    Item : @b<in>  Enum;
+                    Set  : @b<in>  Type_Set := Default_Setting);
+   @b<end> Enumeration_IO;>
+@dby
+@xcode<      @b<procedure> Get(From : @b<in>  String;
+                    Item : @b<out> Enum;
+                    Last : @b<out> Positive)
+         @b<with> Nonblocking;
+      @b<procedure> Put(To   : @b<out> String;
+                    Item : @b<in>  Enum;
+                    Set  : @b<in>  Type_Set := Default_Setting)
+         @b<with> Nonblocking;
+   @b<end> Enumeration_IO;>
+
+!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 @b<is>>
+
+!corrigendum A.16(15/2)
+
+@drepl
+@xcode<   @b<function> Full_Name (Name : @b<in> String) @b<return> String;>
+@dby
+@xcode<   @b<function> Full_Name (Name : @b<in> String) @b<return> String
+      @b<with> Nonblocking;>
+
+!corrigendum A.16(16/2)
+
+@drepl
+@xcode<   @b<function> Simple_Name (Name : @b<in> String) @b<return> String;>
+@dby
+@xcode<   @b<function> Simple_Name (Name : @b<in> String) @b<return> String
+      @b<with> Nonblocking;>
+
+!corrigendum A.16(17/2)
+
+@drepl
+@xcode<   @b<function> Containing_Directory (Name : @b<in> String) @b<return> String;>
+@dby
+@xcode<   @b<function> Containing_Directory (Name : @b<in> String) @b<return> String
+      @b<with> Nonblocking;>
+
+!corrigendum A.16(18/2)
+
+@drepl
+@xcode<   @b<function> Extension (Name : @b<in> String) @b<return> String;>
+@dby
+@xcode<   @b<function> Extension (Name : @b<in> String) @b<return> String
+       @b<with> Nonblocking;>
+
+!corrigendum A.16(19/2)
+
+@drepl
+@xcode<   @b<function> Base_Name (Name : @b<in> String) @b<return> String;>
+@dby
+@xcode<   @b<function> Base_Name (Name : @b<in> String) @b<return> String
+       @b<with> Nonblocking;>
+
+!corrigendum A.16(20/2)
+
+@drepl
+@xcode<   @b<function> Compose (Containing_Directory : @b<in> String := "";
+                     Name                 : @b<in> String;
+                     Extension            : @b<in> String := "") @b<return> String;>
+@dby
+@xcode<   @b<function> Compose (Containing_Directory : @b<in> String := "";
+                     Name                 : @b<in> String;
+                     Extension            : @b<in> String := "") @b<return> String
+      @b<with> Nonblocking;>
+
+!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 @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 @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 @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 @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 @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 @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.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 @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.1(3/3)
+
+@drepl
+@xcode<   @b<function>  Image                  (T : Task_Id) @b<return> String;
+   @b<function>  Current_Task     @b<return> Task_Id;
+   @b<function>  Environment_Task @b<return> Task_Id;
+   @b<procedure> Abort_Task             (T : @b<in> Task_Id);>
+@dby
+@xcode<   @b<function>  Image                  (T : Task_Id) @b<return> String;
+   @b<function>  Current_Task     @b<return> Task_Id;
+   @b<function>  Environment_Task @b<return> Task_Id;
+   @b<procedure> Abort_Task             (T : @b<in> Task_Id)
+       @b<with> Nonblocking =@> False;>
+
+!corrigendum C.7.1(16)
+
+@ddel
+Abort_Task is a potentially blocking operation (see 9.5.1). 
+
+!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 @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 @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 @b<is>>
+
+!corrigendum D.2.1(1.3/3)
+
+@drepl
+@xcode<   @b<procedure> Yield;>
+@dby
+@xcode<   @b<procedure> Yield
+      @b<with> Nonblocking =@> False;>
+
+!corrigendum D.2.1(7/3)
+
+@drepl
+A call of Yield is a task dispatching point. Yield is a potentially blocking
+operation (see 9.5.1). 
+@dby
+A call of Yield is a task dispatching point.
+
+!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 @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 @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 @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 @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 @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 @b<is>>
+
+!corrigendum D.10(4)
+
+@drepl
+@xcode<  @b<type> Suspension_Object @b<is limited private>;
+  @b<procedure> Set_True(S : @b<in out> Suspension_Object);
+  @b<procedure> Set_False(S : @b<in out> Suspension_Object);
+  @b<function> Current_State(S : Suspension_Object) @b<return> Boolean;
+  @b<procedure> Suspend_Until_True(S : @b<in out> Suspension_Object);
+@b<private>
+     ... -- @ft<@i<not specified by the language>>
+@b<end> Ada.Synchronous_Task_Control;>
+@dby
+@xcode<  @b<type> Suspension_Object @b<is limited private>;
+  @b<procedure> Set_True(S : @b<in out> Suspension_Object);
+  @b<procedure> Set_False(S : @b<in out> Suspension_Object);
+  @b<function> Current_State(S : Suspension_Object) @b<return> Boolean;
+  @b<procedure> Suspend_Until_True(S : @b<in out> Suspension_Object)
+     @b<with> Nonblocking =@> False;
+@b<private>
+     ... -- @ft<@i<not specified by the language>>
+@b<end> Ada.Synchronous_Task_Control;>
+
+!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 @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(10)
+
+@drepl
+Program_Error is raised upon calling Suspend_Until_True if another task is
+already waiting on that suspension object. Suspend_Until_True is a
+potentially blocking operation (see 9.5.1).
+@dby
+Program_Error is raised upon calling Suspend_Until_True if another task is
+already waiting on that suspension object.
+
+!corrigendum D.10(10.1/3)
+
+@drepl
+The procedure Suspend_Until_True_And_Set_Deadline blocks the calling task
+until the state of the object S is True; at that point the task becomes ready
+with a deadline of Ada.Real_Time.Clock + TS, and the state of the object
+becomes False. Program_Error is raised upon calling
+Suspend_Until_True_And_Set_Deadline if another task is already waiting on that
+suspension object. Suspend_Until_True_And_Set_Deadline is a potentially
+blocking operation.
+@dby
+The procedure Suspend_Until_True_And_Set_Deadline blocks the calling task
+until the state of the object S is True; at that point the task becomes
+ready with a deadline of Ada.Real_Time.Clock + TS, and the state of the object
+becomes False. Program_Error is raised upon calling
+Suspend_Until_True_And_Set_Deadline if another task is already waiting on that
+suspension object.
+
+!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 @b<is>>
+
+!corrigendum D.10.1(6/3)
+
+@drepl
+@xcode<   @b<procedure> Wait_For_Release (The_Barrier : @b<in out> Synchronous_Barrier;
+                               Notified    :    @b<out> Boolean);>
+@dby
+@xcode<   @b<procedure> Wait_For_Release (The_Barrier : @b<in out> Synchronous_Barrier;
+                               Notified    :    @b<out> Boolean)
+       @b<with> Nonblocking =@> False;>
+
+!corrigendum D.10.1(14/3)
+
+@ddel
+Wait_For_Release is a potentially blocking operation (see 9.5.1). 
+
+!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 @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 @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 @b<is>>
+
+!corrigendum D.14.1(5/2)
+
+@drepl
+@xcode<   @b<type> Timer_Handler @b<is>
+      @b<access protected procedure> (TM : @b<in out> Timer);>
+@dby
+@xcode<   @b<type> Timer_Handler @b<is>
+      @b<access protected procedure> (TM : @b<in out> Timer)
+      @b<with> Nonblocking =@> False;>
+
+!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 @b<is>>
+
+!corrigendum D.14.2(5/2)
+
+@drepl
+@xcode<  @b<type> Group_Budget_Handler @b<is access>
+       @b<protected procedure> (GB : @b<in out> Group_Budget);>
+@dby
+@xcode<  @b<type> Group_Budget_Handler @b<is access>
+       @b<protected procedure> (GB : @b<in out> Group_Budget)
+       @b<with> Nonblocking =@> False;>
+
+!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 @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 @b<is>>
+
+!corrigendum D.15(4/2)
+
+@drepl
+@xcode<  @b<type> Timing_Event @b<is tagged limited private>;
+  @b<type> Timing_Event_Handler
+       @b<is access protected procedure> (Event : @b<in out> Timing_Event);>
+@dby
+@xcode<  @b<type> Timing_Event @b<is tagged limited private>;
+  @b<type> Timing_Event_Handler
+       @b<is access protected procedure> (Event : @b<in out> Timing_Event)
+       @b<with> Nonblocking =@> False;>
+
+!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 @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 @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 @b<is>>
+
+!corrigendum E.5(23)
+
+@ddel
+The subprograms declared in System.RPC are potentially blocking operations. 
+
+!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 @b<is>>
+
+!corrigendum F.3.3(14)
+
+@drepl
+@xcode<      @b<procedure> Put (File       : @b<in> File_Type;
+                     Item       : @b<in> Num;
+                     Pic        : @b<in> Picture;
+                     Currency   : @b<in> String    := Default_Currency;
+                     Fill       : @b<in> Character := Default_Fill;
+                     Separator  : @b<in> Character := Default_Separator;
+                     Radix_Mark : @b<in> Character := Default_Radix_Mark);>
+@dby
+@xcode<      @b<procedure> Put (File       : @b<in> File_Type;
+                     Item       : @b<in> Num;
+                     Pic        : @b<in> Picture;
+                     Currency   : @b<in> String    := Default_Currency;
+                     Fill       : @b<in> Character := Default_Fill;
+                     Separator  : @b<in> Character := Default_Separator;
+                     Radix_Mark : @b<in> Character := Default_Radix_Mark)
+        @b<with> Nonblocking =@> False;>
+
+!corrigendum F.3.3(15)
+
+@drepl
+@xcode<      @b<procedure> Put (Item       : @b<in> Num;
+                     Pic        : @b<in> Picture;
+                     Currency   : @b<in> String    := Default_Currency;
+                     Fill       : @b<in> Character := Default_Fill;
+                     Separator  : @b<in> Character := Default_Separator;
+                     Radix_Mark : @b<in> Character := Default_Radix_Mark);>
+@dby
+@xcode<      @b<procedure> Put (Item       : @b<in> Num;
+                     Pic        : @b<in> Picture;
+                     Currency   : @b<in> String    := Default_Currency;
+                     Fill       : @b<in> Character := Default_Fill;
+                     Separator  : @b<in> Character := Default_Separator;
+                     Radix_Mark : @b<in> Character := Default_Radix_Mark)
+         @b<with> Nonblocking =@> False;>
+
+!corrigendum G.1.1(2/1)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Real @b<is digits> <@>;
+@b<package> Ada.Numerics.Generic_Complex_Types @b<is>
+   @b<pragma> Pure(Generic_Complex_Types);>
+@dby
+@xcode<@b<generic>
+   @b<type> Real @b<is digits> <@>;
+@b<package> Ada.Numerics.Generic_Complex_Types
+   @b<with> Pure, Nonblocking @b<is>>
+
+!corrigendum G.1.2(2/2)
+
+@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<use> Complex_Types;
+@b<package> Ada.Numerics.Generic_Complex_Elementary_Functions @b<is>
+   @b<pragma> Pure(Generic_Complex_Elementary_Functions);>
+@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<use> Complex_Types;
+@b<package> Ada.Numerics.Generic_Complex_Elementary_Functions
+   @b<with> Pure, Nonblocking @b<is>>
+
+!corrigendum G.1.3(8)
+
+@drepl
+@xcode<   @b<procedure> Get (From : @b<in>  String;
+                  Item : @b<out> Complexe;
+                  Last : @b<out> Positive);
+   @b<procedure> Put (To   : @b<out> String;
+                  Item : @b<in>  Complex;
+                  Aft  : @b<in>  Field := Default_Aft;
+                  Exp  : @b<in>  Field := Default_Exp);>
+@dby
+@xcode<   @b<procedure> Get (From : @b<in>  String;
+                  Item : @b<out> Complex;
+                  Last : @b<out> Positive)
+      @b<with> Nonblocking;
+   @b<procedure> Put (To   : @b<out> String;
+                  Item : @b<in>  Complex;
+                  Aft  : @b<in>  Field := Default_Aft;
+                  Exp  : @b<in>  Field := Default_Exp)
+      @b<with> Nonblocking;>
+
+!corrigendum G.3.1(2/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Real @b<is digits> <@>;
+@b<package> Ada.Numerics.Generic_Real_Arrays @b<is>
+   @b<pragma> Pure(Generic_Real_Arrays);>
+@dby
+@xcode<@b<generic>
+   @b<type> Real @b<is digits> <@>;
+@b<package> Ada.Numerics.Generic_Real_Arrays
+   @b<with> Pure, Nonblocking @b<is>>
+
+!corrigendum G.3.2(2/2)
+
+@drepl
+@xcode<@b<with> Ada.Numerics.Generic_Real_Arrays, Ada.Numerics.Generic_Complex_Types;
+@b<generic>
+   @b<with package> Real_Arrays   @b<is new>
+      Ada.Numerics.Generic_Real_Arrays   (<@>);
+   @b<use> Real_Arrays;
+   @b<with package> Complex_Types @b<is new>
+      Ada.Numerics.Generic_Complex_Types (Real);
+   @b<use> Complex_Types;
+@b<package> Ada.Numerics.Generic_Complex_Arrays @b<is>
+   @b<pragma> Pure(Generic_Complex_Arrays);>
+@dby
+@xcode<@b<with> Ada.Numerics.Generic_Real_Arrays, Ada.Numerics.Generic_Complex_Types;
+@b<generic>
+   @b<with package> Real_Arrays   @b<is new>
+      Ada.Numerics.Generic_Real_Arrays   (<@>);
+   @b<use> Real_Arrays;
+   @b<with package> Complex_Types @b<is new>
+      Ada.Numerics.Generic_Complex_Types (Real);
+   @b<use> Complex_Types;
+@b<package> Ada.Numerics.Generic_Complex_Arrays
+   @b<with> Pure, Nonblocking @b<is>>
 
 !ASIS
 

Questions? Ask the ACAA Technical Agent