!comment This file contains Corrigendum conflicts for Amendment 3 (Ada 202x). !comment Conflicts occur when multiple issues change the same !comment paragraph of the standard. !comment This file (and the reading of it in the program) would need to !comment be changed for a new Corrigendum or Amendment. !comment The paragraphs must be in sorted order!! !corrigendum 1.1.3(17/3) !AI-0179-1 !AI-0265-1 @dinsa An implementation conforming to this International Standard may provide additional aspects, attributes, library units, and pragmas. However, it shall not provide any aspect, attribute, library unit, or pragma having the same name as an aspect, attribute, library unit, or pragma (respectively) specified in a Specialized Needs Annex unless the provided construct is either as specified in the Specialized Needs Annex or is more limited in capability than that required by the Annex. A program that attempts to use an unsupported capability of an Annex shall either be identified by the implementation before run time or shall raise an exception at run time. @dinst For an implementation that conforms to this Standard, the implementation of a language-defined unit shall abide by all postconditions, type invariants, and default initial conditions specified for the unit by this International Standard (see 11.4.2). !corrigendum 1.2(3/2) !AI-0058-1 !AI-0224-1 @drepl ISO/IEC 1539-1:2004, @i. @dby ISO/IEC 1539-1:2018, @i. !corrigendum 2.1(4.1/3) !AI-0004-1 !AI-0263-1 @drepl The semantics of an Ada program whose text is not in Normalization Form KC (as defined by Clause 21 of ISO/IEC 10646:2011) is implementation defined. @dby The semantics of an Ada program whose text is not in Normalization Form C (as defined by Clause 21 of ISO/IEC 10646:2017) is implementation defined. !corrigendum 2.3(4/3) !AI-0004-1 !AI-0263-1 @dinsa An @fa shall not contain two consecutive characters in category @fa, or end with a character in that category. @dinst @s8<@i> An identifier shall only contain characters that may be present in Normalization Form KC (as defined by Clause 21 of ISO/IEC 10646:2017). !corrigendum 3.3(23.7/3) !AI-0226-1 !AI-0228-1 @dinsa @xbullet or @fa; or> @dinst @xbullet where the operand denotes a view of a composite object that is known to be constrained; or> !corrigendum 4.2.1(0) !AI-0249-1 !AI-0295-1 @dinsc Using one or more of the aspects defined below, a type may be specified to allow the use of one or more kinds of literals as values of the type. @s8<@i> The following nonoverridable, type-related operational aspects may be specified for any type @i: @xhang<@xterm This aspect is specified by a @i@fa that denotes a primitive function of @i with one parameter of type String and a result type of @i.> @xhang<@xterm This aspect is specified by a @i@fa that denotes a primitive function of @i with one parameter of type String and a result type of @i.> @xhang<@xterm This aspect is specified by a @i@fa that denotes a primitive function of @i with one parameter of type Wide_Wide_String and a result type of @i.> @xindent.> @s8<@i> The Integer_Literal or Real_Literal aspect shall not be specified for a type @i if the full view of @i is a numeric type. The String_Literal aspect shall not be specified for a type @i if the full view of @i is a string type (in the absence of the String_Literal aspect specification). In addition to the places where Legality Rules normally apply (see 12.3), these rules also apply in the private part of an instance of a generic unit. @s8<@i> For the evaluation of an integer (or real) literal with expected type having an Integer_Literal (or Real_Literal) aspect specified, the value is the result of a call on the function specified by the aspect, with the parameter being a string with lower bound one whose value corresponds to the textual representation of the integer (or real) literal. For the evaluation of a @fa with expected type having a String_Literal aspect specified, the value is the result of a call on the function specified by the aspect, with the parameter being the Wide_Wide_String with lower bound one that corresponds to the literal. @s8<@i> It is a bounded error if the evaluation of a literal with expected type having a corresponding _Literal aspect specified, propagates an exception. The possible effect is that an error is reported prior to run time, or Program_Error or the exception propagated by the evaluation is raised at the point of use of the value of the literal. !corrigendum 4.3.1(17/3) !AI-0086-1 !AI-0127-1 @drepl The value of a discriminant that governs a @fa @i

shall be given by a static expression, unless @i

is nested within a @fa @i that is not selected by the discriminant value governing the @fa enclosing @i. @dby For a @fa or @fa, if a @fa @i

is nested within a @fa @i that is not selected by the discriminant value governing the @fa enclosing @i, then there is no restriction on the discriminant governing @i

. Otherwise, the value of the discriminant that governs @i

shall be given by a static expression, or by a nonstatic expression having a constrained static nominal subtype. In this latter case of a nonstatic expression, there shall be exactly one @fa of @i

that covers each value that belongs to the nominal subtype and satisfies the predicates of the subtype, and there shall be at least one such value. !corrigendum 4.3.3(17/3) !AI-0061-1 !AI-0127-1 @drepl The @fa of an @fa is allowed to have a @fa that is a nonstatic @fa or that is a @fa or @fa that defines a nonstatic or null range, only if it is the single @fa of its @fa, and there is only one @fa in the @fa. @dby The @fa of an @fa (including an @fa) is allowed to have a @fa that is a nonstatic @fa or that is a @fa or @fa that defines a nonstatic or null range, only if it is the single @fa of its @fa, and either there is only one @fa in the enclosing @fa or the enclosing @fa is an @fa, not an @fa. !corrigendum 5.5(3/3) !AI-0119-1 !AI-0189-1 !AI-0251-1 @drepl @xcode<@fa@fa< ::= >@ft<@b> @fa | @ft<@b> @fa | @ft<@b> @fa> @dby @xcode<@fa@fa< ::= >@ft<@b> @fa | @ft<@b> @fa | @ft<@b> @fa | @ft<@b> @fa | @ft<@b> [(@fa)] @ft<@b> @fa> @xcode<@fa@fa< ::= >@ft<@i>@fa | @fa @ft<@b> @fa> !corrigendum 5.5(5) !AI-0119-1 !AI-0251-1 @dinsa If a @fa has a @i@fa, then the @fa shall be repeated after the @b; otherwise, there shall not be an @fa after the @fa. @dinst An @fa that begins with the reserved word @b shall not have the reserved word @b in its @fa. @s8<@i> In a @fa that is an @i@fa, the @i@fa is expected to be of any integer type. !corrigendum 5.5(6) !AI-0061-1 !AI-0251-1 @drepl A @fa declares a @i, which is an object whose subtype is that defined by the @fa. @dby A @fa declares a @i, which is an object whose subtype (and nominal subtype) is that defined by the @fa. In a @fa that has a @fa, the @fa declares a @i object whose subtype (and nominal subtype) is that defined by the @fa. !corrigendum 5.5(9/4) !AI-0119-1 !AI-0251-1 !AI-0294-1 @drepl For the execution of a @fa with the @fa being @b @fa, the @fa is first elaborated. This elaboration creates the loop parameter and elaborates the @fa. If the @fa defines a subtype with a null range, the execution of the @fa is complete. Otherwise, the @fa is executed once for each value of the discrete subtype defined by the @fa that satisfies the predicates of the subtype (or until the loop is left as a consequence of a transfer of control). Prior to each such iteration, the corresponding value of the discrete subtype is assigned to the loop parameter. These values are assigned in increasing order unless the reserved word @b is present, in which case the values are assigned in decreasing order. @dby For the execution of a @fa that has an @fa including a @fa, after elaborating the @fa, if any, the @fa is elaborated. This elaboration elaborates the @fa, which defines the subtype of the loop parameter. If the @fa defines a subtype with a null range, the execution of the @fa is complete. Otherwise, the @fa is executed once for each value of the discrete subtype defined by the @fa that satisfies the predicates of the subtype (or until the loop is left as a consequence of a transfer of control). Prior to each such iteration, the corresponding value of the discrete subtype is assigned to the loop parameter associated with the given iteration. If the loop is a parallel loop, each chunk has its own logical thread of control with its own copy of the loop parameter; otherwise (a @i), a single logical thread of control performs the loop, and there is a single copy of the loop parameter. Each logical thread of control handles a distinct subrange of the values of the subtype of the loop parameter such that all values are covered with no overlaps. Within each logical thread of control, the values are assigned to the loop parameter in increasing order unless the reserved word @b is present, in which case the values are assigned in decreasing order. If a @fa with a @fa is present, then the logical thread of control associated with a given chunk has its own copy of the chunk parameter initialized with a distinct value from the discrete subtype defined by the @fa. The values of the chunk parameters are assigned such that they increase with increasing values of the ranges covered by the corresponding loop parameters. Whether or not a @fa is present in a parallel loop, the total number of iterations of the loop represents an upper bound on the number of logical threads of control devoted to the loop. !corrigendum 5.5.2(5/4) !AI-0156-1 !AI-0183-1 @drepl The subtype defined by the @fa, if any, of an array component iterator shall statically match the component subtype of the type of the @i@fa. The subtype defined by the @fa, if any, of a container element iterator shall statically match the default element subtype for the type of the @i@fa. @dby The subtype defined by the @fa, if any, of a generalized iterator shall statically match the iteration cursor subtype. The subtype defined by the @fa, if any, of an array component iterator shall statically match the component subtype of the type of the @i@fa. The subtype defined by the @fa, if any, of a container element iterator shall statically match the default element subtype for the type of the @i@fa. !corrigendum 5.5.3(0) !AI-0189-1 !AI-0292-1 !AI-0294-1 @dinsc A @fa invokes a user-defined procedure, passing in the body of the enclosing @fa as a parameter of an anonymous access-to-procedure type, to allow the loop body to be executed repeatedly as part of the invocation of the user-defined procedure. @s8<@i> @xcode<@fa@fa< ::= > @fa @ft<@b> @fa> @xcode<@fa@fa< ::= > @fa | (@fa{, @fa})> @xcode<@fa@fa< ::= > @ft<@i>@fa | @ft<@i>@fa @fa> @xcode<@fa@fa< ::= > (@fa {, @fa})> @xcode<@fa@fa< ::= > @fa | @fa> @xcode<@fa@fa< ::= > [ @ft<@i>@fa =@> ] <@>> At most one @fa within an @fa shall be a @fa. @s8<@i> The @fa or @fa given in an @fa shall resolve to denote a callable entity @i that is a procedure, or an entry renamed as (viewed as) a procedure. When there is an @fa, the @fa can be an @fa of an access-to-subprogram value. An @fa without a @fa is equivalent to one with an @fa with an additional @fa at the end, with the @i@fa identifying the last formal parameter of the callable entity denoted by the @fa or @fa. An @fa shall contain at most one @fa for each formal parameter of the callable entity @i. Each formal parameter without an @fa shall have a @fa (in the profile of the view of @i denoted by the @fa or @fa). This rule is an overloading rule (see 8.6). The formal parameter of the callable entity @i associated with the @fa shall be of an anonymous access-to-procedure type @i. @s8<@i> The anonymous access-to-procedure type @i shall have at least one formal parameter in its parameter profile. If the @fa is a @fa, then this @fa shall be mode conformant with that of @i. If the @fa is a list of @fas, the number of formal parameters of @i shall be the same as the length of this list. If the @fa or @fa given in an @fa denotes an abstract subprogram, the subprogram shall be a dispatching subprogram. @s8<@i> A @fa with an @fa that has a @fa is equivalent to a local declaration of a procedure P followed by a @fa that is formed from the @fa by replacing the <@> of the @fa with P'Access. The @fa of the locally declared procedure P is formed from the @fa of the anonymous access-to-procedure type @i, by replacing the @fa of each formal parameter of this @fa with the @fa of the corresponding formal parameter or element of the list of @fas given in the @fa. The following aspect may be specified for a subprogram or entry S that has at least one formal parameter of an anonymous access-to-subprogram type: @xhang<@xterm The Allows_Exit aspect is of type Boolean. The specified value shall be static. The Allows_Exit of an inherited primitive subprogram is True if Allows_Exit is True either for the corresponding subprogram of the progenitor type or for any other inherited subprogram that it overrides. If not specified or inherited as True, the Allows_Exit aspect of a subprogram or entry is False.> @xindent @s8<@i> If a subprogram or entry overrides an inherited dispatching subprogram that has a True Allows_Exit aspect, only a confirming specification of True is permitted for the aspect on the overriding declaration. The @fa of a @fa with a @fa as its @fa shall contain an @fa, return statement, @fa, or @fa that leaves the loop only if the callable entity @i associated with the @fa has an Allows_Exit aspect specified True. The @fa of a @fa with a @fa as its @fa shall not contain an @fa whose @fa occurs outside the @fa. @s8<@i> Example of iterating over a map from My_Key_Type to My_Element_Type (see A.18.4): @xcode<@b (C : Cursor) @b My_Map.Iterate @b Put_Line (My_Key_Type'Image (Key (C)) & " =@> " & My_Element_Type'Image (Element (C))); @b;> @xcode<--@ft<@i< The above is equivalent to:>>> @xcode<@b @b P (C : Cursor) @b @b Put_Line (My_Key_Type'Image (Key (c)) & " =@> " & My_Element_Type'Image (Element (C))); @b P; @b My_Map.Iterator (P'Access); @b;> Example of iterating over the environment variables (see A.17): @xcode<@b (Name, Val) @b Ada.Environment_Variables.Iterate(<@>) @b --@ft<@i< "(<@>)" is optional because it is the last parameter>> Put_Line (Name & " =@> " & Val); @b;> @xcode<--@ft<@i< The above is equivalent to:>>> @xcode<@b @b P (Name : String; Val : String) @b @b Put_Line (Name & " =@> " & Val); @b P; @b Ada.Environment_Variables.Iterate (P'Access); @b;> !corrigendum 6.1.1(1/4) !AI-0220-1 !AI-0272-1 @drepl For a noninstance subprogram, a generic subprogram, or an entry, the following language-defined aspects may be specified with an @fa (see 13.1.1): @dby For a noninstance subprogram (including a generic formal subprogram), a generic subprogram, an entry, or an access-to-subprogram type, the following language-defined aspects may be specified with an @fa (see 13.1.1): !corrigendum 6.1.1(29/4) !AI-0185-1 !AI-0220-1 @drepl @xhang<@xtermWithin a postcondition expression for function F, denotes the result object of the function. The type of this attribute is that of the function result except within a Post'Class postcondition expression for a function with a controlling result or with a controlling access result. For a controlling result, the type of the attribute is @i'Class, where @i is the function result type. For a controlling access result, the type of the attribute is an anonymous access type whose designated type is @i'Class, where @i is the designated type of the function result type.> @dby @xhang<@xtermWithin a postcondition expression for F, denotes the return object of the function call for which the postcondition expression is evaluated. The type of this attribute is that of the result subtype of the function or access-to-function type except within a Post'Class postcondition expression for a function with a controlling result or with a controlling access result; in those cases the type of the attribute was described previously.> !corrigendum 6.1.1(39/3) !AI-0220-1 !AI-0272-1 @drepl For a call via an access-to-subprogram value, all precondition and postcondition checks performed are determined by the subprogram or entry denoted by the prefix of the Access attribute reference that produced the value. @dby For a call via an access-to-subprogram value, precondition and postcondition checks performed are as determined by the subprogram or entry denoted by the prefix of the Access attribute reference that produced the value. In addition, a precondition check of any precondition expression associated with the access-to-subprogram type is performed. Similarly, a postcondition check of any postcondition expression associated with the access-to-subprogram type is performed. For a call on a generic formal subprogram, precondition and postcondition checks performed are as determined by the subprogram or entry denoted by the actual subprogram, along with any specific precondition and specific postcondition of the formal subprogram itself. !corrigendum 7.3.2(8/3) !AI-0075-1 !AI-0199-1 @drepl If the Type_Invariant'Class aspect is specified for a tagged type @i, then the invariant expression applies to all descendants of @i. @dby If the Type_Invariant'Class aspect is specified for a tagged type @i, then a @i also applies to each nonabstract descendant @i of @i (including @i itself if it is nonabstract). The corresponding expression is constructed from the associated expression as follows: @xbullet (or to @i itself) are replaced with references to the corresponding components of @i (or to @i as a whole).> @xbullet are replaced with references to the corresponding discriminant of @i, or to the specified value for the discriminant, if the discriminant is specified by the @fa for some type that is an ancestor of @i and a descendant of @i (see 3.7).> If one or more invariant expressions apply to a nonabstract type @i, then a subprogram or entry is said to be @i for @i if @xbullet (or by an instance of a generic unit, and the generic is declared within the immediate scope of type @i), or is the Read or Input stream-oriented attribute of type @i, and either:> @xinbull<@i is a private type or a private extension and the subprogram or entry is visible outside the immediate scope of type @i or overrides an inherited operation that is visible outside the immediate scope of @i; or> @xinbull<@i is a record extension, and the subprogram or entry is a primitive operation visible outside the immediate scope of type @i or overrides an inherited operation that is visible outside the immediate scope of @i.> @xbullet @xinbull;> @xinbull or @b parameters with a part of type @i;> @xinbull; or> @xinbull parameter with a part of type @i.> @xindent is said to be @i for @i.> !corrigendum 7.3.2(20/3) !AI-0075-1 !AI-0193-1 @ddel The check is performed on each such part of type @i. !corrigendum 7.3.3(0) !AI-0265 !AI-0272 @dinsc For a private type or private extension (including a generic formal type), the following language-defined aspect may be specified with an @fa (see 13.1.1): @xhang<@xtermThis aspect shall be specified by an @fa, called a @i. Default_Initial_Condition may be specified on a @fa, a @fa, a @fa, or a @fa.> @s8<@i> The expected type for a default initial condition expression is any boolean type. @s8<@i> The Default_Initial_Condition aspect shall not be specified for a type whose partial view has unknown discriminants, whether explicitly declared or inherited. @s8<@i> If the Default_Initial_Condition aspect is specified for a type T, then the default initial condition expression applies to T and to all descendants of T. @s8<@i> If one or more default initial condition expressions apply to a type T, then a default initial condition check is performed after successful default initialization of an object of type T by default (see 3.3.1). In the case of a controlled type, the check is performed after the call to the type's Initialize procedure (see 7.6). If performing checks is required by the Default_Initial_Condition assertion policy (see 11.4.2) in effect at the point of the corresponding @fa applicable to a given type, then the respective default initial condition expression is considered enabled. The default initial condition check consists of the evaluation of each enabled default initial condition expression that applies to T. These evaluations, if there are more than one, are performed in an arbitrary order. If any of these evaluate to False, Assertions.Assertion_Error is raised at the point of the object initialization. For a generic formal type T, default initial condition checks performed are as determined by the actual type, along with any default initial condition of the formal type itself. !corrigendum 7.3.4(0) !AI-0187-1 !AI-0272-1 !AI-0285-1 @dinsc It is usual that some of the characteristics of a data type are unchanged by most of the primitive operations on the type. Such characteristics are called @i of the type. @s8<@i> A @i of type @i is a function with a single parameter of type @i or of a class-wide type that covers @i. A @i is a list of @fas written in the syntax of a @fa. A @i is a list of @fas preceded by an optional @b written in the syntax of a @fa. For a nonformal private type, nonformal private extension, or full type that does not have a partial view, the following language-defined aspects may be specified with an @fa (see 13.1.1): @xhang<@xtermThis aspect shall be specified by a type property aspect definition; each @fa shall statically denote a single property function of the type. This aspect defines the @i of the associated type.> @xhang<@xtermThis aspect shall be specified by a type property aspect definition; each @fa shall statically denote a single property function of the type. This aspect defines the @i of the associated type. Unlike most class-wide aspects, Stable_Properties'Class is not inherited by descendant types and subprograms, but the enhanced class-wide postconditions are inherited in the normal manner.> For a primitive subprogram, the following language-defined aspects may be specified with an @fa (see 13.1.1): @xhang<@xtermThis aspect shall be specified by a subprogram property aspect definition; each @fa shall statically denote a single property function of a type for which the associated subprogram is primitive.> @xhang<@xtermThis aspect shall be specified by a subprogram property aspect definition; each @fa shall statically denote a single property function of a tagged type for which the associated subprogram is primitive. Unlike most class-wide aspects, Stable_Properties'Class is not inherited by descendant subprograms, but the enhanced class-wide postconditions are inherited in the normal manner.> @s8<@i> A stable property function of a type @i (including a class-wide stable property function) shall have a nonlimited return type and shall be: @xbullet of type @i; or> @xbullet is declared and has a single parameter of mode @b of a class-wide type that covers @i.> In a subprogram property aspect definition for a subprogram @i: @xbullet;> @xbullet shall be a stable property function of a type for which @i is primitive.> @s8<@i> For a primitive subprogram @i of a type @i, the stable property functions for @i for type @i are: @xbullet has an aspect Stable_Properties specified that does not include @b, those functions denoted in the aspect Stable_Properties for @i that have a parameter of @i or @i'Class;> @xbullet has an aspect Stable_Properties specified that includes @b, those functions denoted in the aspect Stable_Properties for @i, excluding those denoted in the aspect Stable_Properties for @i;> @xbullet does not have an aspect Stable_Properties, those functions denoted in the aspect Stable_Properties for @i, if any.> A similar definition applies for class-wide stable property functions by replacing aspect Stable_Properties with aspect Stable_Properties'Class in the above definition. The @i specific postcondition expression for a subprogram @i is the @fa directly specified for @i with the Post aspect. Similarly, the @i class-wide postcondition expression for a subprogram @i is the @fa directly specified for @i with the Post'Class aspect. For every primitive subprogram @i of a type @i that is not a stable property function of @i, the specific postcondition expression of @i is modified to include expressions of the form @fc<@i(@i

) = @i(@i

)'Old>, all @bed with each other and any explicit specific postcondition expression, where @i is each stable property function of @i for type @i that does not occur in the explicit specific postcondition expression of @i, and @i

is each parameter of @i that has type @i. The resulting specific postcondition expression of @i is used in place of the explicit specific postcondition expression of @i when interpreting the meaning of the postcondition as defined in 6.1.1. For every primitive subprogram @i of a type @i that is not a stable property function of @i, the class-wide postcondition expression of @i is modified to include expressions of the form @fc<@i(@i

) = @i(@i

)'Old>, all @bed with each other and any explicit class-wide postcondition expression, where @i is each class-wide stable property function of @i for type @i that does not occur in any class-wide postcondition expression that applies to @i, and @i

is each parameter of @i that has type @i. The resulting class-wide postcondition expression of @i is used in place of the explicit class-wide postcondition expression of @i when interpreting the meaning of the postcondition as defined in 6.1.1. @xindent<@s9> !corrigendum 9.5(17/3) !AI-0064-2 !AI-0247-1 !AI-0267-1 @dinsa In addition to the places where Legality Rules normally apply (see 12.3), these rules also apply in the private part of an instance of a generic unit. @dinss @s8<@i> An @fa is @i if it is one of the following: @xbullet @xbullet;> @xbullet where each operand is nonblocking-static;> @xbullet short-circuit control form where each operand is nonblocking-static;> @xbullet.> For a program unit, task entry, formal package, formal subprogram, formal object of an anonymous access-to-subprogram type, enumeration literal, and for a type (including a formal type), the following language-defined operational aspect is defined: @xhang<@xterm This aspect specifies the blocking restriction for the entity; it shall be specified by an @fa, called a @i. If directly specified, the @fa shall be a nonblocking-static expression. The expected type for the @fa is the predefined type Boolean. The @fa can be omitted from the specification of this aspect; in that case the nonblocking expression for the entity is the enumeration literal True.> @xindent @xindent. If the aspect is statically True for an entity, the entity is said to be @i.> @xindent @xindent @xindent @xindent @xindent @xindent @xindent @xindent @xindent @xindent @xindent @xindent For a @fa S that denotes a subprogram (including a formal subprogram): @xhang<@xterm Denotes whether subprogram S is considered nonblocking; the type of this attribute is the predefined type Boolean.> @xindent S shall statically denote a subprogram.> @xindent For a @fa P that denotes a package (including a formal package): @xhang<@xterm Denotes whether package P is considered nonblocking; the type of this attribute is the predefined type Boolean. P'Nonblocking represents the nonblocking expression of P; evaluation of P'Nonblocking evaluates that expression.> For a @fa S that denotes a subtype (including formal subtypes): @xhang<@xterm Denotes whether predefined operators (and in the case of access-to-subprogram subtypes) a subprogram designated by a value of type S are considered nonblocking; the type of this attribute is the predefined type Boolean. S'Nonblocking represents the nonblocking expression of S; evaluation of S'Nonblocking evaluates that expression.> The following are defined to be @i operations: @xbullet;> @xbullet;> @xbullet, or a call on a procedure that renames or is implemented by an entry;> @xbullet;> @xbullet;> @xbullet @xbullet If a language-defined subprogram allows blocking, then a call on the subprogram is a potentially blocking operation. @s8<@i> A parallel construct or a nonblocking program unit shall not contain, other than within nested units with Nonblocking specified as statically False, a call on a callable entity for which the Nonblocking aspect is statically False, nor shall it contain any of the following: @xbullet;> @xbullet;> @xbullet;> @xbullet;> @xbullet For the purposes of the above rule, an @fa is considered nonblocking if the immediately enclosing protected unit is nonblocking. A subprogram shall be nonblocking if it overrides a nonblocking dispatching operation. An entry shall not implement a nonblocking procedure. If an inherited dispatching subprogram allows blocking, then the corresponding subprogram of each ancestor shall allow blocking. It is illegal to specify aspect Nonblocking for the full view of a type that has a partial view. Aspect Nonblocking shall be specified for a derived type only if it fully conforms to the nonblocking expression of the ancestor type or if it is specified to have the Boolean literal True. If aspect Nonblocking is specified for an entity that is not a generic unit or declared inside of a generic unit, the @fa shall be a static expression. If the prefix of a Nonblocking @fa denotes a generic unit @i, the reference shall occur within the declarative region of @i. The predefined equality operator for a composite type is illegal if it is nonblocking and, for a record type, it is not overridden by a primitive equality operator, and: @xbullet @xbullet