CVS difference for 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