Version 1.6 of 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 WG9 Approved 16-06-22
!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; --
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
... --
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; --
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