Version 1.4 of ai12s/ai12-0241-1.txt

Unformatted version of ai12s/ai12-0241-1.txt version 1.4
Other versions for file ai12s/ai12-0241-1.txt

!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)
Replace the paragraph:
package Ada.Tags is pragma Preelaborate(Tags); type Tag is private; pragma Preelaborable_Initialization(Tag);
by:
package Ada.Tags with Preelaborate, Nonblocking is type Tag is private; pragma Preelaborable_Initialization(Tag);
!corrigendum 3.9(18.2/3)
Replace the paragraph:
generic type T (<>) is abstract tagged limited private; type Parameters (<>) is limited private; with function Constructor (Params : not null access Parameters) return T is abstract; function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : not null access Parameters) return T'Class with Convention => Intrinsic; pragma Preelaborate(Generic_Dispatching_Constructor);
by:
generic type T (<>) is abstract tagged limited private; type Parameters (<>) is limited private; with function Constructor (Params : not null access Parameters) return T is abstract; function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params : not null access Parameters) return T'Class with Preelaborate, Convention => Intrinsic, Nonblocking => Constructor'Nonblocking;
!corrigendum 5.5.1(2/3)
Replace the paragraph:
generic type Cursor; with function Has_Element (Position : Cursor) return Boolean; package Ada.Iterator_Interfaces is pragma Pure (Iterator_Interfaces);
by:
generic type Cursor; with function Has_Element (Position : Cursor) return Boolean; package Ada.Iterator_Interfaces with Pure, Nonblocking => False is
!corrigendum 7.6(4/3)
Replace the paragraph:
package Ada.Finalization is pragma Pure;
by:
package Ada.Finalization with Pure, Nonblocking => False is
!corrigendum 9.6(10)
Replace the paragraph:
package Ada.Calendar is type Time is private;
by:
package Ada.Calendar with Nonblocking is type Time is private;
!corrigendum 9.6.1(2/2)
Replace the paragraph:
package Ada.Calendar.Time_Zones is
by:
package Ada.Calendar.Time_Zones with Nonblocking is
!corrigendum 9.6.1(8/2)
Replace the paragraph:
package Ada.Calendar.Arithmetic is
by:
package Ada.Calendar.Arithmetic with Nonblocking is
!corrigendum 9.6.1(15/2)
Replace the paragraph:
with Ada.Calendar.Time_Zones; package Ada.Calendar.Formatting is
by:
with Ada.Calendar.Time_Zones; package Ada.Calendar.Formatting with Nonblocking is
!corrigendum 11.4.1(2/2)
Replace the paragraph:
with Ada.Streams; package Ada.Exceptions is pragma Preelaborate(Exceptions); type Exception_Id is private; pragma Preelaborable_Initialization(Exception_Id); Null_Id : constant Exception_Id; function Exception_Name(Id : Exception_Id) return String; function Wide_Exception_Name(Id : Exception_Id) return Wide_String; function Wide_Wide_Exception_Name(Id : Exception_Id) return Wide_Wide_String;
by:
with Ada.Streams; package Ada.Exceptions with Preelaborate, Nonblocking is type Exception_Id is private; pragma Preelaborable_Initialization(Exception_Id); Null_Id : constant Exception_Id; function Exception_Name(Id : Exception_Id) return String; function Wide_Exception_Name(Id : Exception_Id) return Wide_String; function Wide_Wide_Exception_Name(Id : Exception_Id) return Wide_Wide_String;
!corrigendum 13.7.2(2)
Replace the paragraph:
generic type Object(<>) is limited private; package System.Address_To_Access_Conversions is pragma Preelaborate(Address_To_Access_Conversions);
by:
generic type Object(<>) is limited private; package System.Address_To_Access_Conversions with Preelaborate, Nonblocking is
!corrigendum 13.9(3/3)
Replace the paragraph:
generic type Source(<>) is limited private; type Target(<>) is limited private; function Ada.Unchecked_Conversion(S : Source) return Target with Convention => Intrinsic; pragma Pure(Ada.Unchecked_Conversion);
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;
!corrigendum 13.11.2(3/3)
Replace the paragraph:
generic type Object(<>) is limited private; type Name is access Object; procedure Ada.Unchecked_Deallocation(X : in out Name) with Convention => Intrinsic; pragma Preelaborate(Ada.Unchecked_Deallocation);
by:
generic type Object(<>) is limited private; type Name is access Object; procedure Ada.Unchecked_Deallocation(X : in out Name) with Preelaborate, Nonblocking, Convention => Intrinsic;
!corrigendum 13.13.1(2)
Replace the paragraph:
package Ada.Streams is pragma Pure(Streams);
by:
package Ada.Streams with Pure, Nonblocking => False is
!corrigendum A.4.3(5)
Replace the paragraph:
with Ada.Strings.Maps; package Ada.Strings.Fixed is pragma Preelaborate(Fixed);
by:
with Ada.Strings.Maps; package Ada.Strings.Fixed with Preelaborate, Nonblocking is
!corrigendum A.4.4(3)
Replace the paragraph:
with Ada.Strings.Maps; package Ada.Strings.Bounded is pragma Preelaborate(Bounded);
by:
with Ada.Strings.Maps; package Ada.Strings.Bounded with Preelaborate, Nonblocking is
!corrigendum A.4.5(3)
Replace the paragraph:
with Ada.Strings.Maps; package Ada.Strings.Unbounded is pragma Preelaborate(Unbounded);
by:
with Ada.Strings.Maps; package Ada.Strings.Unbounded with Preelaborate, Nonblocking is
!corrigendum A.4.7(3)
Replace the paragraph:
package Ada.Strings.Wide_Maps is pragma Preelaborate(Wide_Maps);
by:
package Ada.Strings.Wide_Maps with Preelaborate, Nonblocking is
!corrigendum A.4.8(3/2)
Replace the paragraph:
package Ada.Strings.Wide_Wide_Maps is pragma Preelaborate(Wide_Wide_Maps);
by:
package Ada.Strings.Wide_Wide_Maps with Preelaborate, Nonblocking is
!corrigendum A.4.9(7/3)
Replace the paragraph:
with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Bounded.Hash);
by:
with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash (Key : Bounded.Bounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking;
!corrigendum A.4.9(10/3)
Replace the paragraph:
with Ada.Containers; function Ada.Strings.Unbounded.Hash (Key : Unbounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Unbounded.Hash);
by:
with Ada.Containers; function Ada.Strings.Unbounded.Hash (Key : Unbounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking;
!corrigendum A.4.9(11.7/3)
Replace the paragraph:
with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Bounded.Hash_Case_Insensitive);
by:
with Ada.Containers; generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Hash_Case_Insensitive (Key : Bounded.Bounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking;
!corrigendum A.4.9(11.10/3)
Replace the paragraph:
with Ada.Containers; function Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) return Containers.Hash_Type; pragma Preelaborate(Ada.Strings.Unbounded.Hash_Case_Insensitive);
by:
with Ada.Containers; function Ada.Strings.Unbounded.Hash_Case_Insensitive (Key : Unbounded_String) return Containers.Hash_Type with Preelaborate, Nonblocking;
!corrigendum A.4.10(7/3)
Replace the paragraph:
generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Bounded.Equal_Case_Insensitive);
by:
generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Equal_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean with Preelaborate, Nonblocking;
!corrigendum A.4.10(10/3)
Replace the paragraph:
function Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Unbounded.Equal_Case_Insensitive);
by:
function Ada.Strings.Unbounded.Equal_Case_Insensitive (Left, Right : Unbounded_String) return Boolean with Preelaborate, Nonblocking;
!corrigendum A.4.10(18/3)
Replace the paragraph:
generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Bounded.Less_Case_Insensitive);
by:
generic with package Bounded is new Ada.Strings.Bounded.Generic_Bounded_Length (<>); function Ada.Strings.Bounded.Less_Case_Insensitive (Left, Right : Bounded.Bounded_String) return Boolean with Preelaborate, Nonblocking;
!corrigendum A.4.10(21/3)
Replace the paragraph:
function Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) return Boolean; pragma Preelaborate(Ada.Strings.Unbounded.Less_Case_Insensitive);
by:
function Ada.Strings.Unbounded.Less_Case_Insensitive (Left, Right : Unbounded_String) return Boolean with Preelaborate, Nonblocking;
!corrigendum A.5.1(3)
Replace the paragraph:
generic type Float_Type is digits <>;
package Ada.Numerics.Generic_Elementary_Functions is pragma Pure(Generic_Elementary_Functions);
by:
generic type Float_Type is digits <>;
package Ada.Numerics.Generic_Elementary_Functions with Pure, Nonblocking is
!corrigendum A.10.1(55)
Replace the paragraph:
procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Put(Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Base : in Number_Base := Default_Base);
by:
procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); 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;
!corrigendum A.10.1(60)
Replace the paragraph:
procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Put(Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Base : in Number_Base := Default_Base);
by:
procedure Put(File : in File_Type; Item : in Num; Width : in Field := Default_Width; Base : in Number_Base := Default_Base); 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;
!corrigendum A.10.1(67)
Replace the paragraph:
procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp); end Float_IO;
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;
!corrigendum A.10.1(72)
Replace the paragraph:
procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp); end Fixed_IO;
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;
!corrigendum A.10.1(77)
Replace the paragraph:
procedure Get(From : in String; Item : out Num; Last : out Positive); procedure Put(To : out String; Item : in Num; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp); end Decimal_IO;
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;
!corrigendum A.10.1(83)
Replace the paragraph:
procedure Get(From : in String; Item : out Enum; Last : out Positive); procedure Put(To : out String; Item : in Enum; Set : in Type_Set := Default_Setting); end Enumeration_IO;
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;
!corrigendum A.15(3)
Replace the paragraph:
package Ada.Command_Line is pragma Preelaborate(Command_Line);
by:
package Ada.Command_Line with Preelaborate, Nonblocking is
!corrigendum A.16(15/2)
Replace the paragraph:
function Full_Name (Name : in String) return String;
by:
function Full_Name (Name : in String) return String with Nonblocking;
!corrigendum A.16(16/2)
Replace the paragraph:
function Simple_Name (Name : in String) return String;
by:
function Simple_Name (Name : in String) return String with Nonblocking;
!corrigendum A.16(17/2)
Replace the paragraph:
function Containing_Directory (Name : in String) return String;
by:
function Containing_Directory (Name : in String) return String with Nonblocking;
!corrigendum A.16(18/2)
Replace the paragraph:
function Extension (Name : in String) return String;
by:
function Extension (Name : in String) return String with Nonblocking;
!corrigendum A.16(19/2)
Replace the paragraph:
function Base_Name (Name : in String) return String;
by:
function Base_Name (Name : in String) return String with Nonblocking;
!corrigendum A.16(20/2)
Replace the paragraph:
function Compose (Containing_Directory : in String := ""; Name : in String; Extension : in String := "") return String;
by:
function Compose (Containing_Directory : in String := ""; Name : in String; Extension : in String := "") return String with Nonblocking;
!corrigendum A.16.1(3/3)
Replace the paragraph:
package Ada.Directories.Hierarchical_File_Names is
by:
package Ada.Directories.Hierarchical_File_Names with Nonblocking is
!corrigendum A.17(3/2)
Replace the paragraph:
package Ada.Environment_Variables is pragma Preelaborate(Environment_Variables);
by:
package Ada.Environment_Variables with Preelaborate, Nonblocking is
!corrigendum B.3.1(3)
Replace the paragraph:
package Interfaces.C.Strings is pragma Preelaborate(Strings);
by:
package Interfaces.C.Strings with Preelaborate, Nonblocking is
!corrigendum B.3.2(4)
Replace the paragraph:
generic type Index is (<>); type Element is private; type Element_Array is array (Index range <>) of aliased Element; Default_Terminator : Element; package Interfaces.C.Pointers is pragma Preelaborate(Pointers);
by:
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 is
!corrigendum B.4(7)
Replace the paragraph:
package Interfaces.COBOL is pragma Preelaborate(COBOL);
by:
package Interfaces.COBOL with Preelaborate, Nonblocking is
!corrigendum C.3.2(2/3)
Replace the paragraph:
with System; with System.Multiprocessors; package Ada.Interrupts is type Interrupt_Id is implementation-defined; type Parameterless_Handler is access protected procedure;
by:
with System; with System.Multiprocessors; package Ada.Interrupts with Nonblocking is type Interrupt_Id is implementation-defined; type Parameterless_Handler is access protected procedure with Nonblocking => False;
!corrigendum C.7.1(2/2)
Replace the paragraph:
package Ada.Task_Identification is pragma Preelaborate(Task_Identification); type Task_Id is private; pragma Preelaborable_Initialization (Task_Id); Null_Task_Id : constant Task_Id; function "=" (Left, Right : Task_Id) return Boolean;
by:
package Ada.Task_Identification with Preelaborate, Nonblocking is type Task_Id is private; pragma Preelaborable_Initialization (Task_Id); Null_Task_Id : constant Task_Id; function "=" (Left, Right : Task_Id) return Boolean;
!corrigendum C.7.1(3/3)
Replace the paragraph:
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);
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;
!corrigendum C.7.1(16)
Delete the paragraph:
Abort_Task is a potentially blocking operation (see 9.5.1).
!corrigendum C.7.2(2)
Replace the paragraph:
with Ada.Task_Identification; use Ada.Task_Identification; generic type Attribute is private; Initial_Value : in Attribute; package Ada.Task_Attributes is
by:
with Ada.Task_Identification; use Ada.Task_Identification; generic type Attribute is private; Initial_Value : in Attribute; package Ada.Task_Attributes with Nonblocking is
!corrigendum C.7.3(2/2)
Replace the paragraph:
with Ada.Task_Identification; with Ada.Exceptions; package Ada.Task_Termination is pragma Preelaborate(Task_Termination);
by:
with Ada.Task_Identification; with Ada.Exceptions; package Ada.Task_Termination with Preelaborate, Nonblocking is
!corrigendum D.2.1(1.2/3)
Replace the paragraph:
package Ada.Dispatching is pragma Preelaborate(Dispatching);
by:
package Ada.Dispatching with Preelaborate, Nonblocking is
!corrigendum D.2.1(1.3/3)
Replace the paragraph:
procedure Yield;
by:
procedure Yield with Nonblocking => False;
!corrigendum D.2.1(7/3)
Replace the paragraph:
A call of Yield is a task dispatching point. Yield is a potentially blocking operation (see 9.5.1).
by:
A call of Yield is a task dispatching point.
!corrigendum D.2.4(2.2/3)
Replace the paragraph:
package Ada.Dispatching.Non_Preemptive is pragma Preelaborate(Non_Preemptive); procedure Yield_To_Higher; procedure Yield_To_Same_Or_Higher renames Yield; end Ada.Dispatching.Non_Preemptive;
by:
package Ada.Dispatching.Non_Preemptive with Preelaborate, Nonblocking is procedure Yield_To_Higher; procedure Yield_To_Same_Or_Higher renames Yield; end Ada.Dispatching.Non_Preemptive;
!corrigendum D.2.5(4/2)
Replace the paragraph:
with System; with Ada.Real_Time; package Ada.Dispatching.Round_Robin is Default_Quantum : constant Ada.Real_Time.Time_Span := implementation-defined; procedure Set_Quantum (Pri : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); procedure Set_Quantum (Low, High : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); function Actual_Quantum (Pri : System.Priority) return Ada.Real_Time.Time_Span; function Is_Round_Robin (Pri : System.Priority) return Boolean; end Ada.Dispatching.Round_Robin;
by:
with System; with Ada.Real_Time; package Ada.Dispatching.Round_Robin with Nonblocking is Default_Quantum : constant Ada.Real_Time.Time_Span := implementation-defined; procedure Set_Quantum (Pri : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); procedure Set_Quantum (Low, High : in System.Priority; Quantum : in Ada.Real_Time.Time_Span); function Actual_Quantum (Pri : System.Priority) return Ada.Real_Time.Time_Span; function Is_Round_Robin (Pri : System.Priority) return Boolean; end Ada.Dispatching.Round_Robin;
!corrigendum D.2.6(9/2)
Replace the paragraph:
with Ada.Real_Time; with Ada.Task_Identification; package Ada.Dispatching.EDF is subtype Deadline is Ada.Real_Time.Time; Default_Deadline : constant Deadline := Ada.Real_Time.Time_Last; procedure Set_Deadline (D : in Deadline; T : in Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); procedure Delay_Until_And_Set_Deadline ( Delay_Until_Time : in Ada.Real_Time.Time; Deadline_Offset : in Ada.Real_Time.Time_Span); function Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) return Deadline; end Ada.Dispatching.EDF;
by:
with Ada.Real_Time; with Ada.Task_Identification; package Ada.Dispatching.EDF with Nonblocking is subtype Deadline is Ada.Real_Time.Time; Default_Deadline : constant Deadline := Ada.Real_Time.Time_Last; procedure Set_Deadline (D : in Deadline; T : in Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task); procedure Delay_Until_And_Set_Deadline ( Delay_Until_Time : in Ada.Real_Time.Time; Deadline_Offset : in Ada.Real_Time.Time_Span) with Nonblocking => False; function Get_Deadline (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) return Deadline; end Ada.Dispatching.EDF;
!corrigendum D.5.1(3/2)
Replace the paragraph:
with System; with Ada.Task_Identification; -- See C.7.1 package Ada.Dynamic_Priorities is pragma Preelaborate(Dynamic_Priorities);
by:
with System; with Ada.Task_Identification; -- See C.7.1 package Ada.Dynamic_Priorities with Preelaborate, Nonblocking is
!corrigendum D.8(3)
Replace the paragraph:
package Ada.Real_Time is
by:
package Ada.Real_Time with Nonblocking is
!corrigendum D.10(3/2)
Replace the paragraph:
package Ada.Synchronous_Task_Control is pragma Preelaborate(Synchronous_Task_Control);
by:
package Ada.Synchronous_Task_Control with Preelaborate, Nonblocking is
!corrigendum D.10(4)
Replace the paragraph:
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); private ... -- not specified by the language end Ada.Synchronous_Task_Control;
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;
!corrigendum D.10(5.2/3)
Replace the paragraph:
with Ada.Real_Time; package Ada.Synchronous_Task_Control.EDF is procedure Suspend_Until_True_And_Set_Deadline (S : in out Suspension_Object; TS : in Ada.Real_Time.Time_Span); end Ada.Synchronous_Task_Control.EDF;
by:
with Ada.Real_Time; package Ada.Synchronous_Task_Control.EDF with Nonblocking is procedure Suspend_Until_True_And_Set_Deadline (S : in out Suspension_Object; TS : in Ada.Real_Time.Time_Span) with Nonblocking => False; end Ada.Synchronous_Task_Control.EDF;
!corrigendum D.10(10)
Replace the paragraph:
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).
by:
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)
Replace the paragraph:
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.
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.
!corrigendum D.10.1(3/3)
Replace the paragraph:
package Ada.Synchronous_Barriers is pragma Preelaborate(Synchronous_Barriers);
by:
package Ada.Synchronous_Barriers with Preelaborate, Nonblocking is
!corrigendum D.10.1(6/3)
Replace the paragraph:
procedure Wait_For_Release (The_Barrier : in out Synchronous_Barrier; Notified : out Boolean);
by:
procedure Wait_For_Release (The_Barrier : in out Synchronous_Barrier; Notified : out Boolean) with Nonblocking => False;
!corrigendum D.10.1(14/3)
Delete the paragraph:
Wait_For_Release is a potentially blocking operation (see 9.5.1).
!corrigendum D.11(3/2)
Replace the paragraph:
with Ada.Task_Identification; package Ada.Asynchronous_Task_Control is pragma Preelaborate(Asynchronous_Task_Control); procedure Hold(T : in Ada.Task_Identification.Task_Id); procedure Continue(T : in Ada.Task_Identification.Task_Id); function Is_Held(T : Ada.Task_Identification.Task_Id) return Boolean; end Ada.Asynchronous_Task_Control;
by:
with Ada.Task_Identification; package Ada.Asynchronous_Task_Control with Preelaborate, Nonblocking is procedure Hold(T : in Ada.Task_Identification.Task_Id); procedure Continue(T : in Ada.Task_Identification.Task_Id); function Is_Held(T : Ada.Task_Identification.Task_Id) return Boolean; end Ada.Asynchronous_Task_Control;
!corrigendum D.14(3/2)
Replace the paragraph:
with Ada.Task_Identification; with Ada.Real_Time; use Ada.Real_Time; package Ada.Execution_Time is
by:
with Ada.Task_Identification; with Ada.Real_Time; use Ada.Real_Time; package Ada.Execution_Time with Nonblocking is
!corrigendum D.14.1(3/2)
Replace the paragraph:
with System; package Ada.Execution_Time.Timers is
by:
with System; package Ada.Execution_Time.Timers with Nonblocking is
!corrigendum D.14.1(5/2)
Replace the paragraph:
type Timer_Handler is access protected procedure (TM : in out Timer);
by:
type Timer_Handler is access protected procedure (TM : in out Timer) with Nonblocking => False;
!corrigendum D.14.2(3/3)
Replace the paragraph:
with System; with System.Multiprocessors; package Ada.Execution_Time.Group_Budgets is
by:
with System; with System.Multiprocessors; package Ada.Execution_Time.Group_Budgets with Nonblocking is
!corrigendum D.14.2(5/2)
Replace the paragraph:
type Group_Budget_Handler is access protected procedure (GB : in out Group_Budget);
by:
type Group_Budget_Handler is access protected procedure (GB : in out Group_Budget) with Nonblocking => False;
!corrigendum D.14.3(3/3)
Replace the paragraph:
with Ada.Interrupts; package Ada.Execution_Time.Interrupts is function Clock (Interrupt : Ada.Interrupts.Interrupt_Id) return CPU_Time; function Supported (Interrupt : Ada.Interrupts.Interrupt_Id) return Boolean; end Ada.Execution_Time.Interrupts;
by:
with Ada.Interrupts; package Ada.Execution_Time.Interrupts with Nonblocking is function Clock (Interrupt : Ada.Interrupts.Interrupt_Id) return CPU_Time; function Supported (Interrupt : Ada.Interrupts.Interrupt_Id) return Boolean; end Ada.Execution_Time.Interrupts;
!corrigendum D.15(3/2)
Replace the paragraph:
package Ada.Real_Time.Timing_Events is
by:
package Ada.Real_Time.Timing_Events with Nonblocking is
!corrigendum D.15(4/2)
Replace the paragraph:
type Timing_Event is tagged limited private; type Timing_Event_Handler is access protected procedure (Event : in out Timing_Event);
by:
type Timing_Event is tagged limited private; type Timing_Event_Handler is access protected procedure (Event : in out Timing_Event) with Nonblocking => False;
!corrigendum D.16(3/3)
Replace the paragraph:
package System.Multiprocessors is pragma Preelaborate(Multiprocessors);
by:
package System.Multiprocessors with Preelaborate, Nonblocking is
!corrigendum D.16.1(3/3)
Replace the paragraph:
with Ada.Real_Time; with Ada.Task_Identification; package System.Multiprocessors.Dispatching_Domains is
by:
with Ada.Real_Time; with Ada.Task_Identification; package System.Multiprocessors.Dispatching_Domains with Nonblocking is
!corrigendum E.5(3)
Replace the paragraph:
with Ada.Streams; -- see 13.13.1 package System.RPC is
by:
with Ada.Streams; -- see 13.13.1 package System.RPC with Nonblocking => False is
!corrigendum E.5(23)
Delete the paragraph:
The subprograms declared in System.RPC are potentially blocking operations.
!corrigendum F.3.3(3)
Replace the paragraph:
package Ada.Text_IO.Editing is
by:
package Ada.Text_IO.Editing with Nonblocking is
!corrigendum F.3.3(14)
Replace the paragraph:
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);
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;
!corrigendum F.3.3(15)
Replace the paragraph:
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);
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;
!corrigendum G.1.1(2/1)
Replace the paragraph:
generic type Real is digits <>; package Ada.Numerics.Generic_Complex_Types is pragma Pure(Generic_Complex_Types);
by:
generic type Real is digits <>; package Ada.Numerics.Generic_Complex_Types with Pure, Nonblocking is
!corrigendum G.1.2(2/2)
Replace the paragraph:
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 is pragma Pure(Generic_Complex_Elementary_Functions);
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
!corrigendum G.1.3(8)
Replace the paragraph:
procedure Get (From : in String; Item : out Complexe; Last : out Positive); procedure Put (To : out String; Item : in Complex; Aft : in Field := Default_Aft; Exp : in Field := Default_Exp);
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;
!corrigendum G.3.1(2/2)
Replace the paragraph:
generic type Real is digits <>; package Ada.Numerics.Generic_Real_Arrays is pragma Pure(Generic_Real_Arrays);
by:
generic type Real is digits <>; package Ada.Numerics.Generic_Real_Arrays with Pure, Nonblocking is
!corrigendum G.3.2(2/2)
Replace the paragraph:
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 is pragma Pure(Generic_Complex_Arrays);
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
!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.


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


Questions? Ask the ACAA Technical Agent