!standard 3.9(6/2) 18-01-18 AI12-0241-1/02 !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 ARG Approved 12-0-0 (By Letter Ballot) 18-01-18 !status work item 17-12-14 !status received 17-12-14 !priority Low !difficulty Easy !subject Specifying Nonblocking for Language-Defined Units !summary Aspect Nonblocking is specified for language-defined units as needed to keep compatibility with Ada 2012. !problem AI12-0064-2 defines aspect Nonblocking, and defines language-defined routines with aspect Nonblocking => False as "potentially blocking" (rather a vague English language definition). That means that aspect Nonblocking needs to be specified for many language-defined units and subprograms. !proposal (See Summary.) !wording 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 manageable. These wording changes are just the adding of appropriate aspect clauses, and in a few cases, the deletion of the English text that says something is potentially blocking. If a language-defined package needs to add Nonblocking, any pragma will also be changed to the aspect form at the same time. [Author's note: I've discussed this issue with John; he mainly does not want that to happen for an empty package. The only empty language-defined package is Ada, and that is Pure so no change is needed at this time.] For instance, we'll change package Ada.Command_Line is pragma Preelaborate(Command_Line); to package Ada.Command_Line with Preelaborate, Nonblocking is We intend that language-defined subprograms are nonblocking unless the Standard says otherwise. Specifically, 9.5.1(18) said (before we 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 manipulate files (implicitly or explicitly) are potentially blocking. Other potentially blocking subprograms are identified where they are defined. When not specified as potentially blocking, a language-defined subprogram is nonblocking. 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 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 the contracts at once for those. The entire list of non-container units is: Ada - A.2 - Pure Ada.Assertions — 11.4.2 - Pure Ada.Asynchronous_Task_Control — D.11 - Nonblocking => True Ada.Calendar — 9.6 - Nonblocking => True Ada.Calendar.Arithmetic — 9.6.1 - Nonblocking => True Ada.Calendar.Formatting — 9.6.1 - Nonblocking => True Ada.Calendar.Time_Zones — 9.6.1 - Nonblocking => True Ada.Characters — A.3.1 - Pure Ada.Conversions — A.3.4 - Pure Ada.Handling — A.3.2 - Pure Ada.Latin_1 — A.3.3 - Pure Ada.Command_Line — A.15 - Nonblocking => True Ada.Complex_Text_IO — G.1.3 - Nonblocking => False (** String routines) Ada.Decimal — F.2 - Pure Ada.Direct_IO — A.8.4 - Nonblocking => False (I/O) 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 => 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. -- Yield_to_Same_or_Higher is a rename, and gets the value from the original routine. Ada.Dispatching.Round_Robin — D.2.5 - Nonblocking => True (***** AB.) Ada.Dynamic_Priorities — D.5.1 - Nonblocking => True (***** AB.) Ada.Environment_Variables — A.17 - Nonblocking => True Ada.Exceptions — 11.4.1 - Nonblocking => True Ada.Execution_Time — D.14 - Nonblocking => True Ada.Execution_Time.Group_Budgets — D.14.2 - Nonblocking => True Ada.Execution_Time.Interrupts — D.14.3 - Nonblocking => True Ada.Execution_Time.Timers — D.14.1 - Nonblocking => True Ada.Finalization — 7.6 - Nonblocking => False (*** user overriding) Ada.Float_Text_IO — A.10.9 - Nonblocking => False (** String routines) Ada.Float_Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Float_Wide_Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Integer_Text_IO — A.10.8 - Nonblocking => False (** String routines) Ada.Integer_Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Integer_Wide_Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Interrupts — C.3.2 - Nonblocking => True Ada.Interrupts.Names — C.3.2 - (**** Impl def) Ada.IO_Exceptions — A.13 - Pure Ada.Iterator_Interfaces — 5.5.1 - Nonblocking => False (this declares interfaces used elsewhere, and we have to allow blocking in the -- implemented routines. This is annoying; we may have to make a separate nonblocking version for the parallel stuff) Ada.Locales — A.19 - Nonblocking => True Ada.Numerics — A.5 - Pure Ada.Numerics.Complex_Arrays — G.3.2 - Pure Ada.Numerics.Complex_Elementary_Functions — G.1.2 - Pure Ada.Numerics.Complex_Types — G.1.1 - Pure Ada.Numerics.Discrete_Random — A.5.2 - Nonblocking => True Ada.Numerics.Elementary_Functions — A.5.1 - Pure Ada.Numerics.Float_Random — A.5.2 - Nonblocking => True Ada.Numerics.Generic_Complex_Arrays — G.3.2 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Numerics.Generic_Complex_Elementary_Functions — G.1.2 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Numerics.Generic_Complex_Types — G.1.1 - Nonblocking => True (Pure but generic) Ada.Numerics.Generic_Elementary_Functions — A.5.1 - Nonblocking => True (Pure but generic) Ada.Numerics.Generic_Real_Arrays — G.3.1 - Nonblocking => True (Pure but generic) Ada.Numerics.Real_Arrays — G.3.1 - Pure Ada.Real_Time — D.8 - Nonblocking => True Ada.Real_Time.Timing_Events — D.15 - Nonblocking => True (confirmed by note D.15(48/2)). Ada.Sequential_IO — A.8.1 - Nonblocking => False (I/O) Ada.Storage_IO — A.9 - Nonblocking => False (I/O) Ada.Streams — 13.13.1 - Nonblocking => False (*** user overriding) Ada.Streams.Stream_IO — A.12.1 - Nonblocking => False (I/O) Ada.Strings — A.4.1 - Pure Ada.Strings.Bounded — A.4.4 - Nonblocking => True Ada.Strings.Bounded.Equal_Case_Insensitive — A.4.10 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Bounded.Hash — A.4.9 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Bounded.Hash_Case_Insensitive — A.4.9 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Bounded.Less_Case_Insensitive — A.4.10 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Fixed — A.4.3 - Nonblocking => True Ada.Strings.Fixed.Equal_Case_Insensitive — A.4.10 - Pure (from a rename) Ada.Strings.Fixed.Hash — A.4.9 - Pure Ada.Strings.Fixed.Hash_Case_Insensitive — A.4.9 - Pure Ada.Strings.Fixed.Less_Case_Insensitive — A.4.10 - Pure Ada.Strings.Equal_Case_Insensitive — A.4.10 - Pure Ada.Strings.Hash — A.4.9 - Pure Ada.Strings.Hash_Case_Insensitive — A.4.9 - Pure Ada.Strings.Less_Case_Insensitive — A.4.10 - Pure Ada.Strings.Maps — A.4.2 - Pure Ada.Strings.Maps.Constants — A.4.6 - Pure Ada.Strings.Unbounded — A.4.5 - Nonblocking => True Ada.Strings.Unbounded.Equal_Case_Insensitive — A.4.10 - Nonblocking => True Ada.Strings.Unbounded.Hash — A.4.9 - Nonblocking => True Ada.Strings.Unbounded.Hash_Case_Insensitive — A.4.9 - Nonblocking => True Ada.Strings.Unbounded.Less_Case_Insensitive — A.4.10 - Nonblocking => True Ada.Strings.UTF_Encoding — A.4.11 - Pure Ada.Strings.UTF_Encoding.Conversions — A.4.11 - Pure Ada.Strings.UTF_Encoding.Strings — A.4.11 - Pure Ada.Strings.UTF_Encoding.Wide_Strings — A.4.11 - Pure Ada.Strings.UTF_Encoding.Wide_Wide_Strings — A.4.11 - Pure Ada.Strings.Wide_Bounded — A.4.7 - Nonblocking => True Ada.Strings.Wide_Bounded.Wide_Equal_Case_Insensitive — A.4.7 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Bounded.Wide_Hash — A.4.7 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Bounded.Wide_Hash_Case_Insensitive — A.4.7 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Equal_Case_Insensitive — A.4.7 - Pure Ada.Strings.Wide_Fixed — A.4.7 - Nonblocking => True Ada.Strings.Wide_Fixed.Wide_Equal_Case_Insensitive — A.4.7 - Pure (from a rename) Ada.Strings.Wide_Fixed Wide_Hash — A.4.7 - Pure Ada.Strings.Wide_Fixed Wide_Hash_Case_Insensitive — A.4.7 - Pure Ada.Strings.Wide_Hash — A.4.7 - Pure Ada.Strings.Wide_Hash_Case_Insensitive — A.4.7 - Pure Ada.Strings.Wide_Maps — A.4.7 - Nonblocking => True Ada.Strings.Wide_Maps.Wide_Constants — A.4.7 - Nonblocking => True Ada.Strings.Wide_Unbounded — A.4.7- Nonblocking => True Ada.Strings.Wide_Unbounded.Wide_Equal_Case_Insensitive — A.4.7- Nonblocking => True Ada.Strings.Wide_Unbounded.Wide_Hash — A.4.7- Nonblocking => True Ada.Strings.Wide_Unbounded.Wide_Hash_Case_Insensitive — A.4.7- Nonblocking => True Ada.Strings.Wide_Wide_Bounded — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Equal_Case_Insensitive — A.4.8 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Hash — A.4.8 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Hash_Case_Insensitive — A.4.8 - Nonblocking => True (generic with a formal package, but all matching instances have to have Nonblocking True) Ada.Strings.Wide_Wide_Equal_Case_Insensitive — A.4.8 - Pure Ada.Strings.Wide_Wide_Fixed — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Equal_Case_Insensitive — A.4.8 - Pure (from a renames) Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Hash — A.4.8 - Pure Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Hash_Case_Insensitive — A.4.8 - Pure Ada.Strings.Wide_Wide_Hash — A.4.8 - Pure Ada.Strings.Wide_Wide_Hash_Case_Insensitive - A.4.8 - Pure Ada.Strings.Wide_Wide_Maps — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Unbounded — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Equal_Case_Insensitive — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash — A.4.8 - Nonblocking => True Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash_Case_Insensitive — A.4.8 - Nonblocking => True Ada.Synchronous_Barriers — D.10.1 - Nonblocking => True (Wait_For_Release has Nonblocking => False by D.10.1(14/3); that paragraph should be deleted). Ada.Synchronous_Task_Control — D.10 - Nonblocking => True (Suspend_Until_True has Nonblocking => False by D.10(10), that sentence should be deleted). Ada.Synchronous_Task_Control.EDF — D.10 - Nonblocking => False (by D.10(10.1/3), that sentence should be deleted.) Ada.Tags — 3.9 - Nonblocking => True Ada.Tags.Generic_Dispatching_Constructor — 3.9 - Nonblocking => Constructor'Nonblocking (* generic) Ada.Task_Attributes — C.7.2 - Nonblocking => True Ada.Task_Identification — C.7.1 - Nonblocking => True (Abort_Task has Nonblocking => False by C.7.1(16); that paragraph should be deleted) 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 (** 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 Ada.Unchecked_Conversion — 13.9 - Nonblocking => True (Pure but generic) Ada.Unchecked_Deallocate_Subpool — 13.11.5 - Nonblocking => False (*** user calls) Ada.Unchecked_Deallocation — 13.11.2 - Nonblocking => True Ada.Wide_Characters — A.3.1 - Pure Ada.Wide_Characters.Handling — A.3.5 - Pure Ada.Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Wide_Text_IO.Complex_IO — G.1.4 - Nonblocking => False -- I/O Ada.Wide_Text_IO.Editing — F.3.4 - Nonblocking => False (** String routines) Ada.Wide_Text_IO.Text_Streams — A.12.3 - Nonblocking => False Ada.Wide_Text_IO.Wide_Bounded_IO — A.11 - Nonblocking => False -- I/O Ada.Wide_Text_IO.Wide_Unbounded_IO — A.11 - Nonblocking => False Ada.Wide_Wide_Characters — A.3.1 - Pure Ada.Wide_Wide_Characters.Handling — A.3.6 - Pure Ada.Wide_Wide_Text_IO — A.11 - Nonblocking => False (** String routines) Ada.Wide_Wide_Text_IO.Complex_IO — G.1.4 - Nonblocking => False -- I/O Ada.Wide_Wide_Text_IO.Editing — F.3.4 - Nonblocking => False (** String routines) Ada.Wide_Wide_Text_IO.Text_Streams — A.12.3 - Nonblocking => False Ada.Wide_Wide_Text_IO.Wide_Wide_Bounded_IO — A.11 - Nonblocking => False -- I/O Ada.Wide_Wide_Text_IO.Wide_Wide_Unbounded_IO — A.11 - Nonblocking => False Interfaces — B.2 - Pure Interfaces.C — B.3 - Pure Interfaces.C.Pointers — B.3.2 - Nonblocking => True Interfaces.C.Strings — B.3.1 - Nonblocking => True Interfaces.COBOL — B.4 - Nonblocking => True Interfaces.Fortran — B.5 - Pure System — 13.7 - Pure System.Address_To_Access_Conversions — 13.7.2 - Nonblocking => True System.Machine_Code — 13.8 - (**** Impl def) System.Multiprocessors — D.16 - Nonblocking => True System.Multiprocessors.Dispatching_Domains — D.16.1 - Nonblocking => True System.RPC — E.5 - Nonblocking => False (E.5(23) says this explicitly; that paragraph should be deleted.) System.Storage_Elements — 13.7.1 - Pure System.Storage_Pools — 13.11 - Nonblocking => False (*** user overriding) 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 parameters (see the !discussion for more on this). The containers will be like this as well. Items marked "(** String routines)" have Get/Put routines that operate only on Strings -- those explicitly have Nonblocking => True specified. That's in accordance with the AARM note 9.5.1(18.a) (and an old AI). Items marked "(*** user overriding)" are mainly used to provide a framework for user code (as in storage pools or streams). Since all dispatching calls have to "assume the worst" for nonblocking, and we have to keep compatibility with existing Ada code, we cannot make such packages (and types) nonblocking. The user can explicitly mark their overriding routines Nonblocking (overridings of "allows blocking" subprograms can be declared nonblocking, but the other way around is prohibited). Items marked "(*** user calls)" make calls on code that is potentially user-defined via dispatching. These usually work in conjunction with types declared in packages associated with the previous item. Items marked "(**** impl def)" have implementation-defined contents, so we need say nothing. Items marked "(**** AB)" were verified with Alan Burns. Since explicit wording is needed in Ada 2012 to specify that a routine is potentially blocking, the lack of such wording could mean either that the subprogram was considered and should be nonblocking, or that no one considered whether the subprogram needs to be potentially blocking. As such, I verified with Alan Burns whether any packages that have no evidence that nonblocking was considered need to be explicitly potentially blocking (see e-mail of January 11, 2017, and the reply). In particular, Ada.Dispatching.EDF.Delay_Until_and_Set_Deadline, which includes the semantics of a delay statement, needs to be potentially blocking but isn't declared this way in the RM. !corrigendum 3.9(6/2) @drepl @xcode<@b Ada.Tags @b @b Preelaborate(Tags); @b Tag @b; @b Preelaborable_Initialization(Tag);> @dby @xcode<@b Ada.Tags @b Preelaborate, Nonblocking @b @b Tag @b; @b Preelaborable_Initialization(Tag);> !corrigendum 3.9(18.2/3) @drepl @xcode<@b @b T (<@>) @b; @b Parameters (<@>) @b; @b Constructor (Params : @b Parameters) @b T @b; @b Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : @b Parameters) @b T'Class @b Convention =@> Intrinsic; @b Preelaborate(Generic_Dispatching_Constructor);> @dby @xcode<@b @b T (<@>) @b; @b Parameters (<@>) @b; @b Constructor (Params : @b Parameters) @b T @b; @b Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : @b Parameters) @b T'Class @b Preelaborate, Convention =@> Intrinsic, Nonblocking =@> Constructor'Nonblocking;> !corrigendum 5.5.1(2/3) @drepl @xcode<@b @b Cursor; @b Has_Element (Position : Cursor) @b Boolean; @b Ada.Iterator_Interfaces @b @b Pure (Iterator_Interfaces);> @dby @xcode<@b @b Cursor; @b Has_Element (Position : Cursor) @b Boolean; @b Ada.Iterator_Interfaces @b Pure, Nonblocking =@> False @b> !corrigendum 7.6(4/3) @drepl @xcode<@b Ada.Finalization @b @b Pure;> @dby @xcode<@b Ada.Finalization @b Pure, Nonblocking =@> False @b> !corrigendum 9.6(10) @drepl @xcode< @b Ada.Calendar @b @b Time @b;> @dby @xcode< @b Ada.Calendar @b Nonblocking @b @b Time @b;> !corrigendum 9.6.1(2/2) @drepl @xcode<@b Ada.Calendar.Time_Zones @b> @dby @xcode<@b Ada.Calendar.Time_Zones @b Nonblocking @b> !corrigendum 9.6.1(8/2) @drepl @xcode< @b Ada.Calendar.Arithmetic @b> @dby @xcode< @b Ada.Calendar.Arithmetic @b Nonblocking @b> !corrigendum 9.6.1(15/2) @drepl @xcode< @b Ada.Calendar.Time_Zones; @b Ada.Calendar.Formatting @b> @dby @xcode< @b Ada.Calendar.Time_Zones; @b Ada.Calendar.Formatting @b Nonblocking @b> !corrigendum 11.4.1(2/2) @drepl @xcode<@b Ada.Streams; @b Ada.Exceptions @b @b Preelaborate(Exceptions); @b Exception_Id @b; @b Preelaborable_Initialization(Exception_Id); Null_Id : @b Exception_Id; @b Exception_Name(Id : Exception_Id) @b String; @b Wide_Exception_Name(Id : Exception_Id) @b Wide_String; @b Wide_Wide_Exception_Name(Id : Exception_Id) @b Wide_Wide_String;> @dby @xcode<@b Ada.Streams; @b Ada.Exceptions @b Preelaborate, Nonblocking @b @b Exception_Id @b; @b Preelaborable_Initialization(Exception_Id); Null_Id : @b Exception_Id; @b Exception_Name(Id : Exception_Id) @b String; @b Wide_Exception_Name(Id : Exception_Id) @b Wide_String; @b Wide_Wide_Exception_Name(Id : Exception_Id) @b Wide_Wide_String;> !corrigendum 13.7.2(2) @drepl @xcode<@b @b Object(<@>) @b; @b System.Address_To_Access_Conversions @b @b Preelaborate(Address_To_Access_Conversions);> @dby @xcode<@b @b Object(<@>) @b; @b System.Address_To_Access_Conversions @b Preelaborate, Nonblocking @b> !corrigendum 13.9(3/3) @drepl @xcode<@b @b Source(<@>) @b; @b Target(<@>) @b; @b Ada.Unchecked_Conversion(S : Source) @b Target @b Convention =@> Intrinsic; @b Pure(Ada.Unchecked_Conversion);> @dby @xcode<@b @b Source(<@>) @b; @b Target(<@>) @b; @b Ada.Unchecked_Conversion(S : Source) @b Target @b Pure, Nonblocking, Convention =@> Intrinsic;> !corrigendum 13.11.2(3/3) @drepl @xcode<@b @b Object(<@>) @b; @b Name @b Object; @b Ada.Unchecked_Deallocation(X : @b Name) @b Convention =@> Intrinsic; @b Preelaborate(Ada.Unchecked_Deallocation);> @dby @xcode<@b @b Object(<@>) @b; @b Name @b Object; @b Ada.Unchecked_Deallocation(X : @b Name) @b Preelaborate, Nonblocking, Convention =@> Intrinsic;> !corrigendum 13.13.1(2) @drepl @xcode<@b Ada.Streams @b @b Pure(Streams);> @dby @xcode<@b Ada.Streams @b Pure, Nonblocking =@> False @b> !corrigendum A.4.3(5) @drepl @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Fixed @b @b Preelaborate(Fixed);> @dby @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Fixed @b Preelaborate, Nonblocking @b> !corridendum A.4.4(3) @drepl @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Bounded @b @b Preelaborate(Bounded);> @dby @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Bounded @b Preelaborate, Nonblocking @b> !corridendum A.4.5(3) @drepl @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Unbounded @b @b Preelaborate(Unbounded);> @dby @xcode<@b Ada.Strings.Maps; @b Ada.Strings.Unbounded @b Preelaborate, Nonblocking @b> !corridendum A.4.7(3) @drepl @xcode<@b Ada.Strings.Wide_Maps @b @b Preelaborate(Wide_Maps);> @dby @xcode<@b Ada.Strings.Wide_Maps @b Preelaborate, Nonblocking @b> !corridendum A.4.8(3/2) @drepl @xcode<@b Ada.Strings.Wide_Wide_Maps @b @b Preelaborate(Wide_Wide_Maps);> @dby @xcode<@b Ada.Strings.Wide_Wide_Maps @b Preelaborate, Nonblocking @b> !corrigendum A.4.9(7/3) @drepl @xcode<@b Ada.Containers; @b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) @b Containers.Hash_Type; @b Preelaborate(Ada.Strings.Bounded.Hash);> @dby @xcode<@b Ada.Containers; @b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) @b Containers.Hash_Type @b Preelaborate, Nonblocking;> !corrigendum A.4.9(10/3) @drepl @xcode<@b Ada.Containers; @b Ada.Strings.Unbounded.Hash (Key : Unbounded_String) @b Containers.Hash_Type; @b Preelaborate(Ada.Strings.Unbounded.Hash);> @dby @xcode<@b Ada.Containers; @b Ada.Strings.Unbounded.Hash (Key : Unbounded_String) @b Containers.Hash_Type @b Preelaborate, Nonblocking;> !corrigendum A.4.9(11.7/3) @drepl @xcode<@b Ada.Containers; @b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) @b Containers.Hash_Type; @b Preelaborate(Ada.Strings.Bounded.Hash_Case_Insensitive);> @dby @xcode<@b Ada.Containers; @b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) @b Containers.Hash_Type @b Preelaborate, Nonblocking;> !corrigendum A.4.9(11.10/3) @drepl @xcode<@b Ada.Containers; @b Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) @b Containers.Hash_Type; @b Preelaborate(Ada.Strings.Unbounded.Hash_Case_Insensitive);> @dby @xcode<@b Ada.Containers; @b Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) @b Containers.Hash_Type @b Preelaborate, Nonblocking;> !corrigendum A.4.10(7/3) @drepl @xcode<@b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) @b Boolean; @b Preelaborate(Ada.Strings.Bounded.Equal_Case_Insensitive);> @dby @xcode<@b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) @b Boolean @b Preelaborate, Nonblocking;> !corrigendum A.4.10(10/3) @drepl @xcode<@b Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) @b Boolean; @b Preelaborate(Ada.Strings.Unbounded.Equal_Case_Insensitive);> @dby @xcode<@b Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) @b Boolean @b Preelaborate, Nonblocking;> !corrigendum A.4.10(18/3) @drepl @xcode<@b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) @b Boolean; @b Preelaborate(Ada.Strings.Bounded.Less_Case_Insensitive);> @dby @xcode<@b @b Bounded @b @b Ada.Strings.Bounded.Generic_Bounded_Length (<@>); @b Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) @b Boolean @b Preelaborate, Nonblocking;> !corrigendum A.4.10(21/3) @drepl @xcode<@b Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) @b Boolean; @b Preelaborate(Ada.Strings.Unbounded.Less_Case_Insensitive);> @dby @xcode<@b Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) @b Boolean @b Preelaborate, Nonblocking;> !corrigendum A.5.1(3) @drepl @xcode<@b @b Float_Type @b <@>; @b Ada.Numerics.Generic_Elementary_Functions @b @b Pure(Generic_Elementary_Functions);> @dby @xcode<@b @b Float_Type @b <@>; @b Ada.Numerics.Generic_Elementary_Functions @b Pure, Nonblocking @b> !corrigendum A.10.1(55) @drepl @xcode< @b Put(File : @b File_Type; Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Put(Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Get(From : @b String; Item : @b Num; Last : @b Positive); @b Put(To : @b String; Item : @b Num; Base : @b Number_Base := Default_Base);> @dby @xcode< @b Put(File : @b File_Type; Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Put(Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Get(From : @b String; Item : @b Num; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Num; Base : @b Number_Base := Default_Base) @b Nonblocking;> !corrigendum A.10.1(60) @drepl @xcode< @b Put(File : @b File_Type; Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Put(Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Get(From : @b String; Item : @b Num; Last : @b Positive); @b Put(To : @b String; Item : @b Num; Base : @b Number_Base := Default_Base);> @dby @xcode< @b Put(File : @b File_Type; Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Put(Item : @b Num; Width : @b Field := Default_Width; Base : @b Number_Base := Default_Base); @b Get(From : @b String; Item : @b Num; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Num; Base : @b Number_Base := Default_Base) @b Nonblocking;> !corrigendum A.10.1(67) @drepl @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive); @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp); @b Float_IO;> @dby @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp) @b Nonblocking; @b Float_IO;> !corrigendum A.10.1(72) @drepl @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive); @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp); @b Fixed_IO;> @dby @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp) @b Nonblocking; @b Fixed_IO;> !corrigendum A.10.1(77) @drepl @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive); @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp); @b Decimal_IO;> @dby @xcode< @b Get(From : @b String; Item : @b Num; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Num; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp) @b Nonblocking; @b Decimal_IO;> !corrigendum A.10.1(83) @drepl @xcode< @b Get(From : @b String; Item : @b Enum; Last : @b Positive); @b Put(To : @b String; Item : @b Enum; Set : @b Type_Set := Default_Setting); @b Enumeration_IO;> @dby @xcode< @b Get(From : @b String; Item : @b Enum; Last : @b Positive) @b Nonblocking; @b Put(To : @b String; Item : @b Enum; Set : @b Type_Set := Default_Setting) @b Nonblocking; @b Enumeration_IO;> !corrigendum A.15(3) @drepl @xcode<@b Ada.Command_Line @b @b Preelaborate(Command_Line);> @dby @xcode<@b Ada.Command_Line @b Preelaborate, Nonblocking @b> !corrigendum A.16(15/2) @drepl @xcode< @b Full_Name (Name : @b String) @b String;> @dby @xcode< @b Full_Name (Name : @b String) @b String @b Nonblocking;> !corrigendum A.16(16/2) @drepl @xcode< @b Simple_Name (Name : @b String) @b String;> @dby @xcode< @b Simple_Name (Name : @b String) @b String @b Nonblocking;> !corrigendum A.16(17/2) @drepl @xcode< @b Containing_Directory (Name : @b String) @b String;> @dby @xcode< @b Containing_Directory (Name : @b String) @b String @b Nonblocking;> !corrigendum A.16(18/2) @drepl @xcode< @b Extension (Name : @b String) @b String;> @dby @xcode< @b Extension (Name : @b String) @b String @b Nonblocking;> !corrigendum A.16(19/2) @drepl @xcode< @b Base_Name (Name : @b String) @b String;> @dby @xcode< @b Base_Name (Name : @b String) @b String @b Nonblocking;> !corrigendum A.16(20/2) @drepl @xcode< @b Compose (Containing_Directory : @b String := ""; Name : @b String; Extension : @b String := "") @b String;> @dby @xcode< @b Compose (Containing_Directory : @b String := ""; Name : @b String; Extension : @b String := "") @b String @b Nonblocking;> !corrigendum A.16.1(3/3) @drepl @xcode<@b Ada.Directories.Hierarchical_File_Names @b> @dby @xcode<@b Ada.Directories.Hierarchical_File_Names @b Nonblocking @b> !corrigendum A.17(3/2) @drepl @xcode<@b Ada.Environment_Variables @b @b Preelaborate(Environment_Variables);> @dby @xcode<@b Ada.Environment_Variables @b Preelaborate, Nonblocking @b> !corrigendum B.3.1(3) @drepl @xcode<@b Interfaces.C.Strings @b @b Preelaborate(Strings);> @dby @xcode<@b Interfaces.C.Strings @b Preelaborate, Nonblocking @b> !corrigendum B.3.2(4) @drepl @xcode<@b @b Index @b (<@>); @b Element @b; @b Element_Array @b (Index @b <@>) @b Element; Default_Terminator : Element; @b Interfaces.C.Pointers @b @b Preelaborate(Pointers);> @dby @xcode<@b @b Index @b (<@>); @b Element @b; @b Element_Array @b (Index @b <@>) @b Element; Default_Terminator : Element; @b Interfaces.C.Pointers @b Preelaborate, Nonblocking @b> !corrigendum B.4(7) @drepl @xcode<@b Interfaces.COBOL @b @b Preelaborate(COBOL);> @dby @xcode<@b Interfaces.COBOL @b Preelaborate, Nonblocking @b> !corrigendum C.3.2(2/3) @drepl @xcode<@b System; @b System.Multiprocessors; @b Ada.Interrupts @b @b Interrupt_Id @b @ft<@i>; @b Parameterless_Handler @b @b;> @dby @xcode<@b System; @b System.Multiprocessors; @b Ada.Interrupts @b Nonblocking @b @b Interrupt_Id @b @ft<@i>; @b Parameterless_Handler @b @b @b Nonblocking =@> False;> !corrigendum C.7.1(2/2) @drepl @xcode<@b Ada.Task_Identification @b @b Preelaborate(Task_Identification); @b Task_Id @b; @b Preelaborable_Initialization (Task_Id); Null_Task_Id : @b Task_Id; @b "=" (Left, Right : Task_Id) @b Boolean;> @dby @xcode<@b Ada.Task_Identification @b Preelaborate, Nonblocking @b @b Task_Id @b; @b Preelaborable_Initialization (Task_Id); Null_Task_Id : @b Task_Id; @b "=" (Left, Right : Task_Id) @b Boolean;> !corrigendum C.7.1(3/3) @drepl @xcode< @b Image (T : Task_Id) @b String; @b Current_Task @b Task_Id; @b Environment_Task @b Task_Id; @b Abort_Task (T : @b Task_Id);> @dby @xcode< @b Image (T : Task_Id) @b String; @b Current_Task @b Task_Id; @b Environment_Task @b Task_Id; @b Abort_Task (T : @b Task_Id) @b 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 Ada.Task_Identification; @b Ada.Task_Identification; @b @b Attribute @b; Initial_Value : @b Attribute; @b Ada.Task_Attributes @b> @dby @xcode<@b Ada.Task_Identification; @b Ada.Task_Identification; @b @b Attribute @b; Initial_Value : @b Attribute; @b Ada.Task_Attributes @b Nonblocking @b> !corrigendum C.7.3(2/2) @drepl @xcode<@b Ada.Task_Identification; @b Ada.Exceptions; @b Ada.Task_Termination @b @b Preelaborate(Task_Termination);> @dby @xcode<@b Ada.Task_Identification; @b Ada.Exceptions; @b Ada.Task_Termination @b Preelaborate, Nonblocking @b> !corrigendum D.2.1(1.2/3) @drepl @xcode<@b Ada.Dispatching @b @b Preelaborate(Dispatching);> @dby @xcode<@b Ada.Dispatching @b Preelaborate, Nonblocking @b> !corrigendum D.2.1(1.3/3) @drepl @xcode< @b Yield;> @dby @xcode< @b Yield @b 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 Ada.Dispatching.Non_Preemptive @b @b Preelaborate(Non_Preemptive); @b Yield_To_Higher; @b Yield_To_Same_Or_Higher @b Yield; @b Ada.Dispatching.Non_Preemptive;> @dby @xcode<@b Ada.Dispatching.Non_Preemptive @b Preelaborate, Nonblocking @b @b Yield_To_Higher; @b Yield_To_Same_Or_Higher @b Yield; @b Ada.Dispatching.Non_Preemptive;> !corrigendum D.2.5(4/2) @drepl @xcode<@b System; @b Ada.Real_Time; @b Ada.Dispatching.Round_Robin @b Default_Quantum : @b Ada.Real_Time.Time_Span := @ft<@i>; @b Set_Quantum (Pri : @b System.Priority; Quantum : @b Ada.Real_Time.Time_Span); @b Set_Quantum (Low, High : @b System.Priority; Quantum : @b Ada.Real_Time.Time_Span); @b Actual_Quantum (Pri : System.Priority) @b Ada.Real_Time.Time_Span; @b Is_Round_Robin (Pri : System.Priority) @b Boolean; @b Ada.Dispatching.Round_Robin;> @dby @xcode<@b System; @b Ada.Real_Time; @b Ada.Dispatching.Round_Robin @b Nonblocking @b Default_Quantum : @b Ada.Real_Time.Time_Span := @ft<@i>; @b Set_Quantum (Pri : @b System.Priority; Quantum : @b Ada.Real_Time.Time_Span); @b Set_Quantum (Low, High : @b System.Priority; Quantum : @b Ada.Real_Time.Time_Span); @b Actual_Quantum (Pri : System.Priority) @b Ada.Real_Time.Time_Span; @b Is_Round_Robin (Pri : System.Priority) @b Boolean; @b Ada.Dispatching.Round_Robin;> !corrigendum D.2.6(9/2) @drepl @xcode<@b Ada.Real_Time; @b Ada.Task_Identification; @b Ada.Dispatching.EDF @b @b Deadline @b Ada.Real_Time.Time; Default_Deadline : @b Deadline := Ada.Real_Time.Time_Last; @b Set_Deadline (D : @b Deadline; T : @b Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); @b Delay_Until_And_Set_Deadline ( Delay_Until_Time : @b Ada.Real_Time.Time; Deadline_Offset : @b Ada.Real_Time.Time_Span); @b Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) @b Deadline; @b Ada.Dispatching.EDF;> @dby @xcode<@b Ada.Real_Time; @b Ada.Task_Identification; @b Ada.Dispatching.EDF @b Nonblocking @b @b Deadline @b Ada.Real_Time.Time; Default_Deadline : @b Deadline := Ada.Real_Time.Time_Last; @b Set_Deadline (D : @b Deadline; T : @b Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); @b Delay_Until_And_Set_Deadline ( Delay_Until_Time : @b Ada.Real_Time.Time; Deadline_Offset : @b Ada.Real_Time.Time_Span) @b Nonblocking =@> False; @b Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) @b Deadline; @b Ada.Dispatching.EDF;> !corrigendum D.5.1(3/2) @drepl @xcode<@b System; @b Ada.Task_Identification; @ft<@i<-- See C.7.1>> @b Ada.Dynamic_Priorities @b @b Preelaborate(Dynamic_Priorities);> @dby @xcode<@b System; @b Ada.Task_Identification; @ft<@i<-- See C.7.1>> @b Ada.Dynamic_Priorities @b Preelaborate, Nonblocking @b> !corrigendum D.8(3) @drepl @xcode<@b Ada.Real_Time @b> @dby @xcode<@b Ada.Real_Time @b Nonblocking @b> !corrigendum D.10(3/2) @drepl @xcode<@b Ada.Synchronous_Task_Control @b @b Preelaborate(Synchronous_Task_Control);> @dby @xcode<@b Ada.Synchronous_Task_Control @b Preelaborate, Nonblocking @b> !corrigendum D.10(4) @drepl @xcode< @b Suspension_Object @b; @b Set_True(S : @b Suspension_Object); @b Set_False(S : @b Suspension_Object); @b Current_State(S : Suspension_Object) @b Boolean; @b Suspend_Until_True(S : @b Suspension_Object); @b ... -- @ft<@i> @b Ada.Synchronous_Task_Control;> @dby @xcode< @b Suspension_Object @b; @b Set_True(S : @b Suspension_Object); @b Set_False(S : @b Suspension_Object); @b Current_State(S : Suspension_Object) @b Boolean; @b Suspend_Until_True(S : @b Suspension_Object) @b Nonblocking =@> False; @b ... -- @ft<@i> @b Ada.Synchronous_Task_Control;> !corrigendum D.10(5.2/3) @drepl @xcode<@b Ada.Real_Time; @b Ada.Synchronous_Task_Control.EDF @b @b Suspend_Until_True_And_Set_Deadline (S : @b Suspension_Object; TS : @b Ada.Real_Time.Time_Span); @b Ada.Synchronous_Task_Control.EDF;> @dby @xcode<@b Ada.Real_Time; @b Ada.Synchronous_Task_Control.EDF @b Nonblocking @b @b Suspend_Until_True_And_Set_Deadline (S : @b Suspension_Object; TS : @b Ada.Real_Time.Time_Span) @b Nonblocking =@> False; @b 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 Ada.Synchronous_Barriers @b @b Preelaborate(Synchronous_Barriers);> @dby @xcode<@b Ada.Synchronous_Barriers @b Preelaborate, Nonblocking @b> !corrigendum D.10.1(6/3) @drepl @xcode< @b Wait_For_Release (The_Barrier : @b Synchronous_Barrier; Notified : @b Boolean);> @dby @xcode< @b Wait_For_Release (The_Barrier : @b Synchronous_Barrier; Notified : @b Boolean) @b 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 Ada.Task_Identification; @b Ada.Asynchronous_Task_Control @b @b Preelaborate(Asynchronous_Task_Control); @b Hold(T : @b Ada.Task_Identification.Task_Id); @b Continue(T : @b Ada.Task_Identification.Task_Id); @b Is_Held(T : Ada.Task_Identification.Task_Id) @b Boolean; @b Ada.Asynchronous_Task_Control;> @dby @xcode<@b Ada.Task_Identification; @b Ada.Asynchronous_Task_Control @b Preelaborate, Nonblocking @b @b Hold(T : @b Ada.Task_Identification.Task_Id); @b Continue(T : @b Ada.Task_Identification.Task_Id); @b Is_Held(T : Ada.Task_Identification.Task_Id) @b Boolean; @b Ada.Asynchronous_Task_Control;> !corrigendum D.14(3/2) @drepl @xcode<@b Ada.Task_Identification; @b Ada.Real_Time; @b Ada.Real_Time; @b Ada.Execution_Time @b> @dby @xcode<@b Ada.Task_Identification; @b Ada.Real_Time; @b Ada.Real_Time; @b Ada.Execution_Time @b Nonblocking @b> !corrigendum D.14.1(3/2) @drepl @xcode<@b System; @b Ada.Execution_Time.Timers @b> @dby @xcode<@b System; @b Ada.Execution_Time.Timers @b Nonblocking @b> !corrigendum D.14.1(5/2) @drepl @xcode< @b Timer_Handler @b @b (TM : @b Timer);> @dby @xcode< @b Timer_Handler @b @b (TM : @b Timer) @b Nonblocking =@> False;> !corrigendum D.14.2(3/3) @drepl @xcode<@b System; @b System.Multiprocessors; @b Ada.Execution_Time.Group_Budgets @b> @dby @xcode<@b System; @b System.Multiprocessors; @b Ada.Execution_Time.Group_Budgets @b Nonblocking @b> !corrigendum D.14.2(5/2) @drepl @xcode< @b Group_Budget_Handler @b @b (GB : @b Group_Budget);> @dby @xcode< @b Group_Budget_Handler @b @b (GB : @b Group_Budget) @b Nonblocking =@> False;> !corrigendum D.14.3(3/3) @drepl @xcode<@b Ada.Interrupts; @b Ada.Execution_Time.Interrupts @b @b Clock (Interrupt : Ada.Interrupts.Interrupt_Id) @b CPU_Time; @b Supported (Interrupt : Ada.Interrupts.Interrupt_Id) @b Boolean; @b Ada.Execution_Time.Interrupts;> @dby @xcode<@b Ada.Interrupts; @b Ada.Execution_Time.Interrupts @b Nonblocking @b @b Clock (Interrupt : Ada.Interrupts.Interrupt_Id) @b CPU_Time; @b Supported (Interrupt : Ada.Interrupts.Interrupt_Id) @b Boolean; @b Ada.Execution_Time.Interrupts;> !corrigendum D.15(3/2) @drepl @xcode<@b Ada.Real_Time.Timing_Events @b> @dby @xcode<@b Ada.Real_Time.Timing_Events @b Nonblocking @b> !corrigendum D.15(4/2) @drepl @xcode< @b Timing_Event @b; @b Timing_Event_Handler @b (Event : @b Timing_Event);> @dby @xcode< @b Timing_Event @b; @b Timing_Event_Handler @b (Event : @b Timing_Event) @b Nonblocking =@> False;> !corrigendum D.16(3/3) @drepl @xcode<@b System.Multiprocessors @b @b Preelaborate(Multiprocessors);> @dby @xcode<@b System.Multiprocessors @b Preelaborate, Nonblocking @b> !corrigendum D.16.1(3/3) @drepl @xcode<@b Ada.Real_Time; @b Ada.Task_Identification; @b System.Multiprocessors.Dispatching_Domains @b> @dby @xcode<@b Ada.Real_Time; @b Ada.Task_Identification; @b System.Multiprocessors.Dispatching_Domains @b Nonblocking @b> !corrigendum E.5(3) @drepl @xcode<@b Ada.Streams; -- @ft<@i> @b System.RPC @b> @dby @xcode<@b Ada.Streams; -- @ft<@i> @b System.RPC @b Nonblocking =@> False @b> !corrigendum E.5(23) @ddel The subprograms declared in System.RPC are potentially blocking operations. !corrigendum F.3.3(3) @drepl @xcode<@b Ada.Text_IO.Editing @b> @dby @xcode<@b Ada.Text_IO.Editing @b Nonblocking @b> !corrigendum F.3.3(14) @drepl @xcode< @b Put (File : @b File_Type; Item : @b Num; Pic : @b Picture; Currency : @b String := Default_Currency; Fill : @b Character := Default_Fill; Separator : @b Character := Default_Separator; Radix_Mark : @b Character := Default_Radix_Mark);> @dby @xcode< @b Put (File : @b File_Type; Item : @b Num; Pic : @b Picture; Currency : @b String := Default_Currency; Fill : @b Character := Default_Fill; Separator : @b Character := Default_Separator; Radix_Mark : @b Character := Default_Radix_Mark) @b Nonblocking =@> False;> !corrigendum F.3.3(15) @drepl @xcode< @b Put (Item : @b Num; Pic : @b Picture; Currency : @b String := Default_Currency; Fill : @b Character := Default_Fill; Separator : @b Character := Default_Separator; Radix_Mark : @b Character := Default_Radix_Mark);> @dby @xcode< @b Put (Item : @b Num; Pic : @b Picture; Currency : @b String := Default_Currency; Fill : @b Character := Default_Fill; Separator : @b Character := Default_Separator; Radix_Mark : @b Character := Default_Radix_Mark) @b Nonblocking =@> False;> !corrigendum G.1.1(2/1) @drepl @xcode<@b @b Real @b <@>; @b Ada.Numerics.Generic_Complex_Types @b @b Pure(Generic_Complex_Types);> @dby @xcode<@b @b Real @b <@>; @b Ada.Numerics.Generic_Complex_Types @b Pure, Nonblocking @b> !corrigendum G.1.2(2/2) @drepl @xcode<@b Ada.Numerics.Generic_Complex_Types; @b @b Complex_Types @b @b Ada.Numerics.Generic_Complex_Types (<@>); @b Complex_Types; @b Ada.Numerics.Generic_Complex_Elementary_Functions @b @b Pure(Generic_Complex_Elementary_Functions);> @dby @xcode<@b Ada.Numerics.Generic_Complex_Types; @b @b Complex_Types @b @b Ada.Numerics.Generic_Complex_Types (<@>); @b Complex_Types; @b Ada.Numerics.Generic_Complex_Elementary_Functions @b Pure, Nonblocking @b> !corrigendum G.1.3(8) @drepl @xcode< @b Get (From : @b String; Item : @b Complexe; Last : @b Positive); @b Put (To : @b String; Item : @b Complex; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp);> @dby @xcode< @b Get (From : @b String; Item : @b Complex; Last : @b Positive) @b Nonblocking; @b Put (To : @b String; Item : @b Complex; Aft : @b Field := Default_Aft; Exp : @b Field := Default_Exp) @b Nonblocking;> !corrigendum G.3.1(2/2) @drepl @xcode<@b @b Real @b <@>; @b Ada.Numerics.Generic_Real_Arrays @b @b Pure(Generic_Real_Arrays);> @dby @xcode<@b @b Real @b <@>; @b Ada.Numerics.Generic_Real_Arrays @b Pure, Nonblocking @b> !corrigendum G.3.2(2/2) @drepl @xcode<@b Ada.Numerics.Generic_Real_Arrays, Ada.Numerics.Generic_Complex_Types; @b @b Real_Arrays @b Ada.Numerics.Generic_Real_Arrays (<@>); @b Real_Arrays; @b Complex_Types @b Ada.Numerics.Generic_Complex_Types (Real); @b Complex_Types; @b Ada.Numerics.Generic_Complex_Arrays @b @b Pure(Generic_Complex_Arrays);> @dby @xcode<@b Ada.Numerics.Generic_Real_Arrays, Ada.Numerics.Generic_Complex_Types; @b @b Real_Arrays @b Ada.Numerics.Generic_Real_Arrays (<@>); @b Real_Arrays; @b Complex_Types @b Ada.Numerics.Generic_Complex_Types (Real); @b Complex_Types; @b Ada.Numerics.Generic_Complex_Arrays @b Pure, Nonblocking @b> !ASIS No ASIS effect. !ACATS test ACATS B-Tests can be written to check that language-defined subprograms with Nonblocking set to False cannot be called from a subprogram with Nonblocking => True. !appendix From: Randy Brukardt Sent: Thursday, January 18, 2018 9:01 PM Following is a summary of the votes on the Triple Letter Ballot. All three of these votes passed as expected. ============= Letter Ballot for AI12-0241-1/01: Approve AI as written [9] Steve Baird, Randy Brukardt, Bob Duff, Brad Moore, Erhard Ploedereder, Jean-Pierre Rosen, Ed Schonberg, Tucker Taft, and Tullio Vardanega. Approve AI with comments [3] John Barnes [A question about the default, a thought about pragma Preelaborable_Initialization. Answered in the thread.] Jeff Cousins [the comments box is blank on this ballot, so perhaps the wrong box was checked? How do we count hanging chads? :-)] Gary Dismukes [notes two typos, now fixed in version /02] Reject AI [0] Abstain [0] Not voting [4]: Raphaλl Amiard, Alan Burns, Pascal Leroy, and Florian Schanda. ****************************************************************