2.1:
character::= graphic_character | format_effector | other_control_function

2.1:
graphic_character::= identifier_letter | digit | space_character | special_character

2.3:
identifier::= 
   identifier_start {identifier_start | identifier_extend} identifier_letter {[underline] letter_or_digit}

2.3:
identifier_start letter_or_digit::= 
     letter_uppercase
   | letter_lowercase
   | letter_titlecase
   | letter_modifier
   | letter_other
   | number_letter identifier_letter | digit

2.3:
identifier_extend::= 
     mark_non_spacing
   | mark_spacing_combining
   | number_decimal
   | punctuation_connector
   | other_format

2.4:
numeric_literal::= decimal_literal | based_literal

2.4.1:
decimal_literal::= numeral [.numeral] [exponent]

2.4.1:
numeral::= digit {[underline] digit}

2.4.1:
exponent::= E [+] numeral | E – numeral

2.4.1:
digit::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

2.4.2:
based_literal::= 
   base # based_numeral [.based_numeral] # [exponent]

2.4.2:
base::= numeral

2.4.2:
based_numeral::= 
   extended_digit {[underline] extended_digit}

2.4.2:
extended_digit::= digit | A | B | C | D | E | F

2.5:
character_literal::= 'graphic_character'

2.6:
string_literal::= "{string_element}"

2.6:
string_element::= "" | non_quotation_mark_graphic_character

2.7:
comment::= --{non_end_of_line_character}

2.8:
pragma::= 
   pragma identifier [(pragma_argument_association {, pragma_argument_association})];

2.8:
pragma_argument_association::= 
     [pragma_argument_identifier =>] name
   | [pragma_argument_identifier =>] expression

3.1:
basic_declaration::= 
     type_declaration | subtype_declaration
   | object_declaration | number_declaration
   | subprogram_declaration | abstract_subprogram_declaration
   | null_procedure_declaration | package_declaration
   | | renaming_declaration |
   | exception_declaration
   | | generic_declaration |
   | generic_instantiation

3.1:
defining_identifier::= identifier

3.2.1:
type_declaration::=  full_type_declaration
   | incomplete_type_declaration
   | private_type_declaration
   | private_extension_declaration

3.2.1:
full_type_declaration::= 
     type defining_identifier [known_discriminant_part] is type_definition;
   | task_type_declaration
   | protected_type_declaration

3.2.1:
type_definition::= 
     enumeration_type_definition | integer_type_definition
   | real_type_definition | array_type_definition
   | record_type_definition | access_type_definition
   | derived_type_definition | interface_type_definition

3.2.2:
subtype_declaration::= 
   subtype defining_identifier is subtype_indication;

3.2.2:
subtype_indication::=  [null_exclusion] subtype_mark [constraint]

3.2.2:
subtype_mark::= subtype_name

3.2.2:
constraint::= scalar_constraint | composite_constraint

3.2.2:
scalar_constraint::= 
     range_constraint | digits_constraint | delta_constraint

3.2.2:
composite_constraint::= 
     index_constraint | discriminant_constraint

3.3.1:
object_declaration::= 
    defining_identifier_list : [aliased] [constant] subtype_indication [:= expression];
  | defining_identifier_list : [aliased] [constant] access_definition [:= expression];
  | defining_identifier_list : [aliased] [constant] array_type_definition [:= expression];
  | single_task_declaration
  | single_protected_declaration

3.3.1:
defining_identifier_list::= 
  defining_identifier {, defining_identifier}

3.3.2:
number_declaration::= 
     defining_identifier_list : constant := static_expression;

3.4:
derived_type_definition::= 
    [abstract] [limited] new parent_subtype_indication [[and interface_list] record_extension_part]

3.5:
range_constraint::=  range range

3.5:
range::=  range_attribute_reference
   | simple_expression .. simple_expression

3.5.1:
enumeration_type_definition::= 
   (enumeration_literal_specification {, enumeration_literal_specification})

3.5.1:
enumeration_literal_specification::=  defining_identifier | defining_character_literal

3.5.1:
defining_character_literal::= character_literal

3.5.4:
integer_type_definition::= signed_integer_type_definition | modular_type_definition

3.5.4:
signed_integer_type_definition::= range static_simple_expression .. static_simple_expression

3.5.4:
modular_type_definition::= mod static_expression

3.5.6:
real_type_definition::= 
   floating_point_definition | fixed_point_definition

3.5.7:
floating_point_definition::= 
  digits static_expression [real_range_specification]

3.5.7:
real_range_specification::= 
  range static_simple_expression .. static_simple_expression

3.5.9:
fixed_point_definition::= ordinary_fixed_point_definition | decimal_fixed_point_definition

3.5.9:
ordinary_fixed_point_definition::= 
   delta static_expression  real_range_specification

3.5.9:
decimal_fixed_point_definition::= 
   delta static_expression digits static_expression [real_range_specification]

3.5.9:
digits_constraint::= 
   digits static_expression [range_constraint]

3.6:
array_type_definition::= 
   unconstrained_array_definition | constrained_array_definition

3.6:
unconstrained_array_definition::= 
   array(index_subtype_definition {, index_subtype_definition}) of component_definition

3.6:
index_subtype_definition::= subtype_mark range <>

3.6:
constrained_array_definition::= 
   array (discrete_subtype_definition {, discrete_subtype_definition}) of component_definition

3.6:
discrete_subtype_definition::= discrete_subtype_indication | range

3.6:
component_definition::= 
   [aliased] subtype_indication
 | [aliased] access_definition

3.6.1:
index_constraint::=  (discrete_range {, discrete_range})

3.6.1:
discrete_range::= discrete_subtype_indication | range

3.7:
discriminant_part::= unknown_discriminant_part | known_discriminant_part

3.7:
unknown_discriminant_part::= (<>)

3.7:
known_discriminant_part::= 
   (discriminant_specification {; discriminant_specification})

3.7:
discriminant_specification::= 
   defining_identifier_list : [null_exclusion] subtype_mark [:= default_expression]
 | defining_identifier_list : access_definition [:= default_expression]

3.7:
default_expression::= expression

3.7.1:
discriminant_constraint::= 
   (discriminant_association {, discriminant_association})

3.7.1:
discriminant_association::= 
   [discriminant_selector_name {| discriminant_selector_name} =>] expression

3.8:
record_type_definition::= [[abstract] tagged] [limited] record_definition

3.8:
record_definition::= 
    record
       component_list
    end record
  | null record

3.8:
component_list::= 
      component_item {component_item}
   | {component_item} variant_part
   |  null;

3.8:
component_item::= component_declaration | aspect_clause representation_clause

3.8:
component_declaration::= 
   defining_identifier_list : component_definition [:= default_expression];

3.8.1:
variant_part::= 
   case discriminant_direct_name is
       variant
      {variant}
   end case;

3.8.1:
variant::= 
   when discrete_choice_list =>
      component_list

3.8.1:
discrete_choice_list::= discrete_choice {| discrete_choice}

3.8.1:
discrete_choice::= expression | discrete_range | others

3.9.1:
record_extension_part::= with record_definition

3.9.3:
abstract_subprogram_declaration::= 
    [overriding_indicator]
    subprogram_specification is abstract;

3.9.4:
interface_type_definition::= 
    [limited | task | protected | synchronized] interface [and interface_list]

3.9.4:
interface_list::= interface_subtype_mark {and interface_subtype_mark}

3.10:
access_type_definition::= 
    [null_exclusion] access_to_object_definition
  | [null_exclusion] access_to_subprogram_definition

3.10:
access_to_object_definition::= 
    access [general_access_modifier] subtype_indication

3.10:
general_access_modifier::= all | constant

3.10:
access_to_subprogram_definition::= 
    access [protected] procedure parameter_profile
  | access [protected] function  parameter_and_result_profile

3.10:
null_exclusion::= not null

3.10:
access_definition::= 
    [null_exclusion] access [constant] subtype_mark
  | [null_exclusion] access [protected] procedure parameter_profile
  | [null_exclusion] access [protected] function parameter_and_result_profile access subtype_mark

3.10.1:
incomplete_type_declaration::= type defining_identifier [discriminant_part] [is tagged];

3.11:
declarative_part::= {declarative_item}

3.11:
declarative_item::= 
    basic_declarative_item | body

3.11:
basic_declarative_item::= 
    basic_declaration | aspect_clause representation_clause | use_clause

3.11:
body::= proper_body | body_stub

3.11:
proper_body::= 
    subprogram_body | package_body | task_body | protected_body

4.1:
name::= 
     direct_name | explicit_dereference
   | indexed_component | slice
   | selected_component | attribute_reference
   | type_conversion | function_call
   | character_literal

4.1:
direct_name::= identifier | operator_symbol

4.1:
prefix::= name | implicit_dereference

4.1:
explicit_dereference::= name.all

4.1:
implicit_dereference::= name

4.1.1:
indexed_component::= prefix(expression {, expression})

4.1.2:
slice::= prefix(discrete_range)

4.1.3:
selected_component::= prefix . selector_name

4.1.3:
selector_name::= identifier | character_literal | operator_symbol

4.1.4:
attribute_reference::= prefix'attribute_designator

4.1.4:
attribute_designator::= 
    identifier[(static_expression)]
  | Access | Delta | Digits

4.1.4:
range_attribute_reference::= prefix'range_attribute_designator

4.1.4:
range_attribute_designator::= Range[(static_expression)]

4.3:
aggregate::= record_aggregate | extension_aggregate | array_aggregate

4.3.1:
record_aggregate::= (record_component_association_list)

4.3.1:
record_component_association_list::= 
    record_component_association {, record_component_association}
  | null record

4.3.1:
record_component_association::= 
    [component_choice_list =>] expression
   | component_choice_list => <>

4.3.1:
component_choice_list::= 
     component_selector_name {| component_selector_name}
   | others

4.3.2:
extension_aggregate::= 
    (ancestor_part with record_component_association_list)

4.3.2:
ancestor_part::= expression | subtype_mark

4.3.3:
array_aggregate::= 
  positional_array_aggregate | named_array_aggregate

4.3.3:
positional_array_aggregate::= 
    (expression, expression {, expression})
  | (expression {, expression}, others => expression)
  | (expression {, expression}, others => <>)

4.3.3:
named_array_aggregate::= 
    (array_component_association {, array_component_association})

4.3.3:
array_component_association::= 
    discrete_choice_list => expression
  | discrete_choice_list => <>

4.4:
expression::= 
     relation {and relation}  | relation {and then relation}
   | relation {or relation}  | relation {or else relation}
   | relation {xor relation}

4.4:
relation::= 
     simple_expression [relational_operator simple_expression]
   | simple_expression [not] in range
   | simple_expression [not] in subtype_mark

4.4:
simple_expression::= [unary_adding_operator] term {binary_adding_operator term}

4.4:
term::= factor {multiplying_operator factor}

4.4:
factor::= primary [** primary] | abs primary | not primary

4.4:
primary::= 
   numeric_literal | null | string_literal | aggregate
 | name | qualified_expression | allocator | (expression)

4.5:
logical_operator::=   and | or  | xor

4.5:
relational_operator::=   =   | /=  | <   | <= | > | >=

4.5:
binary_adding_operator::=   +   | –   | &

4.5:
unary_adding_operator::=   +   | –

4.5:
multiplying_operator::=   *   | /   | mod | rem

4.5:
highest_precedence_operator::=   **  | abs | not

4.6:
type_conversion::= 
    subtype_mark(expression)
  | subtype_mark(name)

4.7:
qualified_expression::= 
   subtype_mark'(expression) | subtype_mark'aggregate

4.8:
allocator::= 
   new subtype_indication | new qualified_expression

5.1:
sequence_of_statements::= statement {statement}

5.1:
statement::= 
   {label} simple_statement | {label} compound_statement

5.1:
simple_statement::= null_statement
   | assignment_statement | exit_statement
   | goto_statement | procedure_call_statement
   | simple_return_statement return_statement | entry_call_statement
   | requeue_statement | delay_statement
   | abort_statement | raise_statement
   | code_statement

5.1:
compound_statement::= 
     if_statement | case_statement
   | loop_statement | block_statement
   | extended_return_statement
   | accept_statement | select_statement

5.1:
null_statement::= null;

5.1:
label::= <<label_statement_identifier>>

5.1:
statement_identifier::= direct_name

5.2:
assignment_statement::= 
   variable_name := expression;

5.3:
if_statement::= 
    if condition then
      sequence_of_statements
   {elsif condition then
      sequence_of_statements}
   [else
      sequence_of_statements]
    end if;

5.3:
condition::= boolean_expression

5.4:
case_statement::= 
   case expression is
       case_statement_alternative
      {case_statement_alternative}
   end case;

5.4:
case_statement_alternative::= 
   when discrete_choice_list =>
      sequence_of_statements

5.5:
loop_statement::= 
   [loop_statement_identifier:]
      [iteration_scheme] loop
         sequence_of_statements
       end loop [loop_identifier];

5.5:
iteration_scheme::= while condition
   | for loop_parameter_specification

5.5:
loop_parameter_specification::= 
   defining_identifier in [reverse] discrete_subtype_definition

5.6:
block_statement::= 
   [block_statement_identifier:]
       [declare
            declarative_part]
        begin
            handled_sequence_of_statements
        end [block_identifier];

5.7:
exit_statement::= 
   exit [loop_name] [when condition];

5.8:
goto_statement::= goto label_name;

6.1:
subprogram_declaration::= 
    [overriding_indicator]
    subprogram_specification;

6.1:
abstract_subprogram_declaration::= subprogram_specification is abstract;

6.1:
subprogram_specification::= 
    procedure_specification
  | function_specification
    procedure defining_program_unit_name parameter_profile
  | function defining_designator parameter_and_result_profile

6.1:
procedure_specification::= procedure defining_program_unit_name parameter_profile

6.1:
function_specification::= function defining_designator parameter_and_result_profile

6.1:
designator::= [parent_unit_name . ]identifier | operator_symbol

6.1:
defining_designator::= defining_program_unit_name | defining_operator_symbol

6.1:
defining_program_unit_name::= [parent_unit_name . ]defining_identifier

6.1:
operator_symbol::= string_literal

6.1:
defining_operator_symbol::= operator_symbol

6.1:
parameter_profile::= [formal_part]

6.1:
parameter_and_result_profile::= 
    [formal_part] return [null_exclusion] subtype_mark
  | [formal_part] return access_definition

6.1:
formal_part::= 
   (parameter_specification {; parameter_specification})

6.1:
parameter_specification::= 
    defining_identifier_list : mode [null_exclusion] subtype_mark [:= default_expression]
  | defining_identifier_list : access_definition [:= default_expression]

6.1:
mode::= [in] | in out | out

6.3:
subprogram_body::= 
    [overriding_indicator]
    subprogram_specification is
       declarative_part
    begin
        handled_sequence_of_statements
    end [designator];

6.4:
procedure_call_statement::= 
    procedure_name;
  | procedure_prefix actual_parameter_part;

6.4:
function_call::= 
    function_name
  | function_prefix actual_parameter_part

6.4:
actual_parameter_part::= 
    (parameter_association {, parameter_association})

6.4:
parameter_association::= 
   [formal_parameter_selector_name =>] explicit_actual_parameter

6.4:
explicit_actual_parameter::= expression | variable_name

6.5:
simple_return_statement return_statement::= return [expression];

6.5:
extended_return_statement::= 
    return defining_identifier : [aliased] return_subtype_indication [:= expression] [do
        handled_sequence_of_statements
    end return];

6.5:
return_subtype_indication::= subtype_indication | access_definition

6.7:
null_procedure_declaration::= 
   [overriding_indicator]
   procedure_specification is null;

7.1:
package_declaration::= package_specification;

7.1:
package_specification::= 
    package defining_program_unit_name is
      {basic_declarative_item}
   [private
      {basic_declarative_item}]
    end [[parent_unit_name.]identifier]

7.2:
package_body::= 
    package body defining_program_unit_name is
       declarative_part
   [begin
        handled_sequence_of_statements]
    end [[parent_unit_name.]identifier];

7.3:
private_type_declaration::= 
   type defining_identifier [discriminant_part] is [[abstract] tagged] [limited] private;

7.3:
private_extension_declaration::= 
   type defining_identifier [discriminant_part] is
     [abstract] [limited | synchronized] new ancestor_subtype_indication
     [and interface_list] with private;

8.3.1:
overriding_indicator::= [not] overriding

8.4:
use_clause::= use_package_clause | use_type_clause

8.4:
use_package_clause::= use package_name {, package_name};

8.4:
use_type_clause::= use type subtype_mark {, subtype_mark};

8.5:
renaming_declaration::= 
      object_renaming_declaration
    | exception_renaming_declaration
    | package_renaming_declaration
    | subprogram_renaming_declaration
    | generic_renaming_declaration

8.5.1:
object_renaming_declaration::= 
    defining_identifier : [null_exclusion] subtype_mark renames object_name;
  | defining_identifier : access_definition renames object_name;

8.5.2:
exception_renaming_declaration::= defining_identifier : exception renames exception_name;

8.5.3:
package_renaming_declaration::= package defining_program_unit_name renames package_name;

8.5.4:
subprogram_renaming_declaration::= 
    [overriding_indicator]
    subprogram_specification renames callable_entity_name;

8.5.5:
generic_renaming_declaration::= 
    generic package defining_program_unit_name renames generic_package_name;
  | generic procedure defining_program_unit_name renames generic_procedure_name;
  | generic function defining_program_unit_name renames generic_function_name;

9.1:
task_type_declaration::= 
   task type defining_identifier [known_discriminant_part] [is
     [new interface_list with]
     task_definition];

9.1:
single_task_declaration::= 
   task defining_identifier [is
     [new interface_list with]
     task_definition];

9.1:
task_definition::= 
     {task_item}
  [ private
     {task_item}]
  end [task_identifier]

9.1:
task_item::= entry_declaration | aspect_clause representation_clause

9.1:
task_body::= 
   task body defining_identifier is
     declarative_part
   begin
     handled_sequence_of_statements
   end [task_identifier];

9.4:
protected_type_declaration::= 
  protected type defining_identifier [known_discriminant_part] is
     [new interface_list with]
     protected_definition;

9.4:
single_protected_declaration::= 
  protected defining_identifier is
     [new interface_list with]
     protected_definition;

9.4:
protected_definition::= 
    { protected_operation_declaration }
[ private
    { protected_element_declaration } ]
  end [protected_identifier]

9.4:
protected_operation_declaration::= subprogram_declaration
     | entry_declaration
     | aspect_clause representation_clause

9.4:
protected_element_declaration::= protected_operation_declaration
     | component_declaration

9.4:
protected_body::= 
  protected body defining_identifier is
   { protected_operation_item }
  end [protected_identifier];

9.4:
protected_operation_item::= subprogram_declaration
     | subprogram_body
     | entry_body
     | aspect_clause representation_clause

9.5.2:
entry_declaration::= 
   [overriding_indicator]
   entry defining_identifier [(discrete_subtype_definition)] parameter_profile;

9.5.2:
accept_statement::= 
   accept entry_direct_name [(entry_index)] parameter_profile [do
     handled_sequence_of_statements
   end [entry_identifier]];

9.5.2:
entry_index::= expression

9.5.2:
entry_body::= 
  entry defining_identifier  entry_body_formal_part  entry_barrier is
    declarative_part
  begin
    handled_sequence_of_statements
  end [entry_identifier];

9.5.2:
entry_body_formal_part::= [(entry_index_specification)] parameter_profile

9.5.2:
entry_barrier::= when condition

9.5.2:
entry_index_specification::= for defining_identifier in discrete_subtype_definition

9.5.3:
entry_call_statement::= entry_name [actual_parameter_part];

9.5.4:
requeue_statement::= requeue entry_name [with abort];

9.6:
delay_statement::= delay_until_statement | delay_relative_statement

9.6:
delay_until_statement::= delay until delay_expression;

9.6:
delay_relative_statement::= delay delay_expression;

9.7:
select_statement::= 
   selective_accept
  | timed_entry_call
  | conditional_entry_call
  | asynchronous_select

9.7.1:
selective_accept::= 
  select
   [guard]
     select_alternative
{ or
   [guard]
     select_alternative }
[ else
   sequence_of_statements ]
  end select;

9.7.1:
guard::= when condition =>

9.7.1:
select_alternative::= 
   accept_alternative
  | delay_alternative
  | terminate_alternative

9.7.1:
accept_alternative::= 
  accept_statement [sequence_of_statements]

9.7.1:
delay_alternative::= 
  delay_statement [sequence_of_statements]

9.7.1:
terminate_alternative::= terminate;

9.7.2:
timed_entry_call::= 
  select
   entry_call_alternative
  or
   delay_alternative
  end select;

9.7.2:
entry_call_alternative::= 
  procedure_or_entry_call entry_call_statement [sequence_of_statements]

9.7.2:
procedure_or_entry_call::= 
  procedure_call_statement | entry_call_statement

9.7.3:
conditional_entry_call::= 
  select
   entry_call_alternative
  else
   sequence_of_statements
  end select;

9.7.4:
asynchronous_select::= 
  select
   triggering_alternative
  then abort
   abortable_part
  end select;

9.7.4:
triggering_alternative::= triggering_statement [sequence_of_statements]

9.7.4:
triggering_statement::= procedure_or_entry_call entry_call_statement | delay_statement

9.7.4:
abortable_part::= sequence_of_statements

9.8:
abort_statement::= abort task_name {, task_name};

10.1.1:
compilation::= {compilation_unit}

10.1.1:
compilation_unit::= 
    context_clause library_item
  | context_clause subunit

10.1.1:
library_item::= [private] library_unit_declaration
  | library_unit_body
  | [private] library_unit_renaming_declaration

10.1.1:
library_unit_declaration::= 
     subprogram_declaration | package_declaration
   | generic_declaration | generic_instantiation

10.1.1:
library_unit_renaming_declaration::= 
   package_renaming_declaration
 | generic_renaming_declaration
 | subprogram_renaming_declaration

10.1.1:
library_unit_body::= subprogram_body | package_body

10.1.1:
parent_unit_name::= name

10.1.2:
context_clause::= {context_item}

10.1.2:
context_item::= with_clause | use_clause

10.1.2:
with_clause::= limited_with_clause | nonlimited_with_clause with library_unit_name {, library_unit_name};

10.1.2:
limited_with_clause::= limited [private] with library_unit_name {, library_unit_name};

10.1.2:
nonlimited_with_clause::= [private] with library_unit_name {, library_unit_name};

10.1.3:
body_stub::= subprogram_body_stub | package_body_stub | task_body_stub | protected_body_stub

10.1.3:
subprogram_body_stub::= 
   [overriding_indicator]
   subprogram_specification is separate;

10.1.3:
package_body_stub::= package body defining_identifier is separate;

10.1.3:
task_body_stub::= task body defining_identifier is separate;

10.1.3:
protected_body_stub::= protected body defining_identifier is separate;

10.1.3:
subunit::= separate (parent_unit_name) proper_body

11.1:
exception_declaration::= defining_identifier_list : exception;

11.2:
handled_sequence_of_statements::= 
     sequence_of_statements
  [exception
     exception_handler
    {exception_handler}]

11.2:
exception_handler::= 
  when [choice_parameter_specification:] exception_choice {| exception_choice} =>
     sequence_of_statements

11.2:
choice_parameter_specification::= defining_identifier

11.2:
exception_choice::= exception_name | others

11.3:
raise_statement::= raise;
      | raise exception_name [with string_expression]; raise [exception_name];

12.1:
generic_declaration::= generic_subprogram_declaration | generic_package_declaration

12.1:
generic_subprogram_declaration::= 
     generic_formal_part  subprogram_specification;

12.1:
generic_package_declaration::= 
     generic_formal_part  package_specification;

12.1:
generic_formal_part::= generic {generic_formal_parameter_declaration | use_clause}

12.1:
generic_formal_parameter_declaration::= 
      formal_object_declaration
    | formal_type_declaration
    | formal_subprogram_declaration
    | formal_package_declaration

12.3:
generic_instantiation::= 
     package defining_program_unit_name is
         new generic_package_name [generic_actual_part];
   | [overriding_indicator]
     procedure defining_program_unit_name is
         new generic_procedure_name [generic_actual_part];
   | [overriding_indicator]
     function defining_designator is
         new generic_function_name [generic_actual_part];

12.3:
generic_actual_part::= 
   (generic_association {, generic_association})

12.3:
generic_association::= 
   [generic_formal_parameter_selector_name =>] explicit_generic_actual_parameter

12.3:
explicit_generic_actual_parameter::= expression | variable_name
   | subprogram_name | entry_name | subtype_mark
   | package_instance_name

12.4:
formal_object_declaration::= 
    defining_identifier_list : mode [null_exclusion] subtype_mark [:= default_expression];
    defining_identifier_list : mode access_definition [:= default_expression];

12.5:
formal_type_declaration::= 
    type defining_identifier[discriminant_part] is formal_type_definition;

12.5:
formal_type_definition::= 
      formal_private_type_definition
    | formal_derived_type_definition
    | formal_discrete_type_definition
    | formal_signed_integer_type_definition
    | formal_modular_type_definition
    | formal_floating_point_definition
    | formal_ordinary_fixed_point_definition
    | formal_decimal_fixed_point_definition
    | formal_array_type_definition
    | formal_access_type_definition
    | formal_interface_type_definition

12.5.1:
formal_private_type_definition::= [[abstract] tagged] [limited] private

12.5.1:
formal_derived_type_definition::= 
     [abstract] [limited | synchronized] new subtype_mark [[and interface_list] with private]

12.5.2:
formal_discrete_type_definition::= (<>)

12.5.2:
formal_signed_integer_type_definition::= range <>

12.5.2:
formal_modular_type_definition::= mod <>

12.5.2:
formal_floating_point_definition::= digits <>

12.5.2:
formal_ordinary_fixed_point_definition::= delta <>

12.5.2:
formal_decimal_fixed_point_definition::= delta <> digits <>

12.5.3:
formal_array_type_definition::= array_type_definition

12.5.4:
formal_access_type_definition::= access_type_definition

12.5.5:
formal_interface_type_definition::= interface_type_definition

12.6:
formal_subprogram_declaration::= formal_concrete_subprogram_declaration
    | formal_abstract_subprogram_declaration with subprogram_specification [is subprogram_default];

12.6:
formal_concrete_subprogram_declaration::= 
     with subprogram_specification [is subprogram_default];

12.6:
formal_abstract_subprogram_declaration::= 
     with subprogram_specification is abstract [subprogram_default];

12.6:
subprogram_default::= default_name | <> | null

12.6:
default_name::= name

12.7:
formal_package_declaration::= 
    with package defining_identifier is new generic_package_name  formal_package_actual_part;

12.7:
formal_package_actual_part::= 
    ([others =>] <>)
  | [generic_actual_part]
  | (formal_package_association {, formal_package_association} [, others => <>])(<>) | [generic_actual_part]

12.7:
formal_package_association::= 
    generic_association
  | generic_formal_parameter_selector_name => <>

13.1:
aspect_clause representation_clause::= attribute_definition_clause
      | enumeration_representation_clause
      | record_representation_clause
      | at_clause

13.1:
local_name::= direct_name
      | direct_name'attribute_designator
      | library_unit_name

13.3:
attribute_definition_clause::= 
      for local_name'attribute_designator use expression;
    | for local_name'attribute_designator use name;

13.4:
enumeration_representation_clause::= 
    for first_subtype_local_name use enumeration_aggregate;

13.4:
enumeration_aggregate::= array_aggregate

13.5.1:
record_representation_clause::= 
    for first_subtype_local_name use
      record [mod_clause]
        {component_clause}
      end record;

13.5.1:
component_clause::= 
    component_local_name at position range first_bit .. last_bit;

13.5.1:
position::= static_expression

13.5.1:
first_bit::= static_simple_expression

13.5.1:
last_bit::= static_simple_expression

13.8:
code_statement::= qualified_expression;

13.12:
restriction::= restriction_identifier
    | restriction_parameter_identifier => restriction_parameter_argument expression

13.12:
restriction_parameter_argument::= name | expression

J.3:
delta_constraint::= delta static_expression [range_constraint]

J.7:
at_clause::= for direct_name use at expression;

J.8:
mod_clause::= at mod static_expression;

abort_statement
     simple_statement   5.1

abortable_part
     asynchronous_select   9.7.4

abstract_subprogram_declaration
     basic_declaration   3.1

accept_alternative
     select_alternative   9.7.1

accept_statement
     accept_alternative   9.7.1
     compound_statement   5.1

access_definition
     component_definition   3.6
     discriminant_specification   3.7
     formal_object_declaration   12.4
     object_declaration   3.3.1
     object_renaming_declaration   8.5.1
     parameter_and_result_profile   6.1
     parameter_specification   6.1
     return_subtype_indication   6.5

access_to_object_definition
     access_type_definition   3.10

access_to_subprogram_definition
     access_type_definition   3.10

access_type_definition
     formal_access_type_definition   12.5.4
     type_definition   3.2.1

actual_parameter_part
     entry_call_statement   9.5.3
     function_call   6.4
     procedure_call_statement   6.4

aggregate
     primary   4.4
     qualified_expression   4.7

allocator
     primary   4.4

ancestor_part
     extension_aggregate   4.3.2

array_aggregate
     aggregate   4.3
     enumeration_aggregate   13.4

array_component_association
     named_array_aggregate   4.3.3

array_type_definition
     formal_array_type_definition   12.5.3
     object_declaration   3.3.1
     type_definition   3.2.1

aspect_clause
     basic_declarative_item   3.11
     component_item   3.8
     protected_operation_declaration   9.4
     protected_operation_item   9.4
     task_item   9.1

assignment_statement
     simple_statement   5.1

asynchronous_select
     select_statement   9.7

at_clause
     aspect_clause   13.1

attribute_definition_clause
     aspect_clause   13.1

attribute_designator
     attribute_definition_clause   13.3
     attribute_reference   4.1.4
     local_name   13.1

attribute_reference
     name   4.1

base
     based_literal   2.4.2

based_literal
     numeric_literal   2.4

based_numeral
     based_literal   2.4.2

basic_declaration
     basic_declarative_item   3.11

basic_declarative_item
     declarative_item   3.11
     package_specification   7.1

binary_adding_operator
     simple_expression   4.4

block_statement
     compound_statement   5.1

body
     declarative_item   3.11

body_stub
     body   3.11

case_statement
     compound_statement   5.1

case_statement_alternative
     case_statement   5.4

character
     comment   2.7

character_literal
     defining_character_literal   3.5.1
     name   4.1
     selector_name   4.1.3

choice_parameter_specification
     exception_handler   11.2

code_statement
     simple_statement   5.1

compilation_unit
     compilation   10.1.1

component_choice_list
     record_component_association   4.3.1

component_clause
     record_representation_clause   13.5.1

component_declaration
     component_item   3.8
     protected_element_declaration   9.4

component_definition
     component_declaration   3.8
     constrained_array_definition   3.6
     unconstrained_array_definition   3.6

component_item
     component_list   3.8

component_list
     record_definition   3.8
     variant   3.8.1

composite_constraint
     constraint   3.2.2

compound_statement
     statement   5.1

condition
     entry_barrier   9.5.2
     exit_statement   5.7
     guard   9.7.1
     if_statement   5.3
     iteration_scheme   5.5

conditional_entry_call
     select_statement   9.7

constrained_array_definition
     array_type_definition   3.6

constraint
     subtype_indication   3.2.2

context_clause
     compilation_unit   10.1.1

context_item
     context_clause   10.1.2

decimal_fixed_point_definition
     fixed_point_definition   3.5.9

decimal_literal
     numeric_literal   2.4

declarative_item
     declarative_part   3.11

declarative_part
     block_statement   5.6
     entry_body   9.5.2
     package_body   7.2
     subprogram_body   6.3
     task_body   9.1

default_expression
     component_declaration   3.8
     discriminant_specification   3.7
     formal_object_declaration   12.4
     parameter_specification   6.1

default_name
     subprogram_default   12.6

defining_character_literal
     enumeration_literal_specification   3.5.1

defining_designator
     function_specification   6.1
     generic_instantiation   12.3
     subprogram_specification   6.1

defining_identifier
     choice_parameter_specification   11.2
     defining_identifier_list   3.3.1
     defining_program_unit_name   6.1
     entry_body   9.5.2
     entry_declaration   9.5.2
     entry_index_specification   9.5.2
     enumeration_literal_specification   3.5.1
     exception_renaming_declaration   8.5.2
     extended_return_statement   6.5
     formal_package_declaration   12.7
     formal_type_declaration   12.5
     full_type_declaration   3.2.1
     incomplete_type_declaration   3.10.1
     loop_parameter_specification   5.5
     object_renaming_declaration   8.5.1
     package_body_stub   10.1.3
     private_extension_declaration   7.3
     private_type_declaration   7.3
     protected_body   9.4
     protected_body_stub   10.1.3
     protected_type_declaration   9.4
     single_protected_declaration   9.4
     single_task_declaration   9.1
     subtype_declaration   3.2.2
     task_body   9.1
     task_body_stub   10.1.3
     task_type_declaration   9.1

defining_identifier_list
     component_declaration   3.8
     discriminant_specification   3.7
     exception_declaration   11.1
     formal_object_declaration   12.4
     number_declaration   3.3.2
     object_declaration   3.3.1
     parameter_specification   6.1

defining_operator_symbol
     defining_designator   6.1

defining_program_unit_name
     defining_designator   6.1
     generic_instantiation   12.3
     generic_renaming_declaration   8.5.5
     package_body   7.2
     package_renaming_declaration   8.5.3
     package_specification   7.1
     procedure_specification   6.1
     subprogram_specification   6.1

delay_alternative
     select_alternative   9.7.1
     timed_entry_call   9.7.2

delay_relative_statement
     delay_statement   9.6

delay_statement
     delay_alternative   9.7.1
     simple_statement   5.1
     triggering_statement   9.7.4

delay_until_statement
     delay_statement   9.6

delta_constraint
     scalar_constraint   3.2.2

derived_type_definition
     type_definition   3.2.1

designator
     subprogram_body   6.3

digit
                                               2.1
     extended_digit   2.4.2
     identifier_start   2.3
     numeral   2.4.1

digits_constraint
     scalar_constraint   3.2.2

direct_name
     accept_statement   9.5.2
     at_clause   J.7
     local_name   13.1
     name   4.1
     statement_identifier   5.1
     variant_part   3.8.1

discrete_choice
     discrete_choice_list   3.8.1

discrete_choice_list
     array_component_association   4.3.3
     case_statement_alternative   5.4
     variant   3.8.1

discrete_range
     discrete_choice   3.8.1
     index_constraint   3.6.1
     slice   4.1.2

discrete_subtype_definition
     constrained_array_definition   3.6
     entry_declaration   9.5.2
     entry_index_specification   9.5.2
     loop_parameter_specification   5.5

discriminant_association
     discriminant_constraint   3.7.1

discriminant_constraint
     composite_constraint   3.2.2

discriminant_part
     formal_type_declaration   12.5
     incomplete_type_declaration   3.10.1
     private_extension_declaration   7.3
     private_type_declaration   7.3

discriminant_specification
     known_discriminant_part   3.7

entry_barrier
     entry_body   9.5.2

entry_body
     protected_operation_item   9.4

entry_body_formal_part
     entry_body   9.5.2

entry_call_alternative
     conditional_entry_call   9.7.3
     timed_entry_call   9.7.2

entry_call_statement
     entry_call_alternative   9.7.2
     procedure_or_entry_call   9.7.2
     simple_statement   5.1
     triggering_statement   9.7.4

entry_declaration
     protected_operation_declaration   9.4
     task_item   9.1

entry_index
     accept_statement   9.5.2

entry_index_specification
     entry_body_formal_part   9.5.2

enumeration_aggregate
     enumeration_representation_clause   13.4

enumeration_literal_specification
     enumeration_type_definition   3.5.1

enumeration_representation_clause
     aspect_clause   13.1

enumeration_type_definition
     type_definition   3.2.1

exception_choice
     exception_handler   11.2

exception_declaration
     basic_declaration   3.1

exception_handler
     handled_sequence_of_statements   11.2

exception_renaming_declaration
     renaming_declaration   8.5

exit_statement
     simple_statement   5.1

explicit_actual_parameter
     parameter_association   6.4

explicit_dereference
     name   4.1

explicit_generic_actual_parameter
     generic_association   12.3

exponent
     based_literal   2.4.2
     decimal_literal   2.4.1

expression
     ancestor_part   4.3.2
     array_component_association   4.3.3
     assignment_statement   5.2
     at_clause   J.7
     attribute_definition_clause   13.3
     attribute_designator   4.1.4
     case_statement   5.4
     condition   5.3
     decimal_fixed_point_definition   3.5.9
     default_expression   3.7
     delay_relative_statement   9.6
     delay_until_statement   9.6
     delta_constraint   J.3
     digits_constraint   3.5.9
     discrete_choice   3.8.1
     discriminant_association   3.7.1
     entry_index   9.5.2
     explicit_actual_parameter   6.4
     explicit_generic_actual_parameter   12.3
     extended_return_statement   6.5
     floating_point_definition   3.5.7
     indexed_component   4.1.1
     mod_clause   J.8
     modular_type_definition   3.5.4
     number_declaration   3.3.2
     object_declaration   3.3.1
     ordinary_fixed_point_definition   3.5.9
     position   13.5.1
     positional_array_aggregate   4.3.3
     pragma_argument_association   2.8
     primary   4.4
     qualified_expression   4.7
     raise_statement   11.3
     range_attribute_designator   4.1.4
     record_component_association   4.3.1
     restriction   13.12
     restriction_parameter_argument   13.12
     simple_return_statement   6.5
     type_conversion   4.6

extended_digit
     based_numeral   2.4.2

extended_return_statement
     compound_statement   5.1

extension_aggregate
     aggregate   4.3

factor
     term   4.4

first_bit
     component_clause   13.5.1

fixed_point_definition
     real_type_definition   3.5.6

floating_point_definition
     real_type_definition   3.5.6

formal_abstract_subprogram_declaration
     formal_subprogram_declaration   12.6

formal_access_type_definition
     formal_type_definition   12.5

formal_array_type_definition
     formal_type_definition   12.5

formal_concrete_subprogram_declaration
     formal_subprogram_declaration   12.6

formal_decimal_fixed_point_definition
     formal_type_definition   12.5

formal_derived_type_definition
     formal_type_definition   12.5

formal_discrete_type_definition
     formal_type_definition   12.5

formal_floating_point_definition
     formal_type_definition   12.5

formal_interface_type_definition
     formal_type_definition   12.5

formal_modular_type_definition
     formal_type_definition   12.5

formal_object_declaration
     generic_formal_parameter_declaration   12.1

formal_ordinary_fixed_point_definition
     formal_type_definition   12.5

formal_package_actual_part
     formal_package_declaration   12.7

formal_package_association
     formal_package_actual_part   12.7

formal_package_declaration
     generic_formal_parameter_declaration   12.1

formal_part
     parameter_and_result_profile   6.1
     parameter_profile   6.1

formal_private_type_definition
     formal_type_definition   12.5

formal_signed_integer_type_definition
     formal_type_definition   12.5

formal_subprogram_declaration
     generic_formal_parameter_declaration   12.1

formal_type_declaration
     generic_formal_parameter_declaration   12.1

formal_type_definition
     formal_type_declaration   12.5

format_effector
                                               2.1

full_type_declaration
     type_declaration   3.2.1

function_call
     name   4.1

function_specification
     subprogram_specification   6.1

general_access_modifier
     access_to_object_definition   3.10

generic_actual_part
     formal_package_actual_part   12.7
     generic_instantiation   12.3

generic_association
     formal_package_association   12.7
     generic_actual_part   12.3

generic_declaration
     basic_declaration   3.1
     library_unit_declaration   10.1.1

generic_formal_parameter_declaration
     generic_formal_part   12.1

generic_formal_part
     generic_package_declaration   12.1
     generic_subprogram_declaration   12.1

generic_instantiation
     basic_declaration   3.1
     library_unit_declaration   10.1.1

generic_package_declaration
     generic_declaration   12.1

generic_renaming_declaration
     library_unit_renaming_declaration   10.1.1
     renaming_declaration   8.5

generic_subprogram_declaration
     generic_declaration   12.1

goto_statement
     simple_statement   5.1

graphic_character
                                               2.1
     character_literal   2.5
     string_element   2.6

guard
     selective_accept   9.7.1

handled_sequence_of_statements
     accept_statement   9.5.2
     block_statement   5.6
     entry_body   9.5.2
     extended_return_statement   6.5
     package_body   7.2
     subprogram_body   6.3
     task_body   9.1

identifier
     accept_statement   9.5.2
     attribute_designator   4.1.4
     block_statement   5.6
     defining_identifier   3.1
     designator   6.1
     direct_name   4.1
     entry_body   9.5.2
     loop_statement   5.5
     package_body   7.2
     package_specification   7.1
     pragma   2.8
     pragma_argument_association   2.8
     protected_body   9.4
     protected_definition   9.4
     restriction   13.12
     selector_name   4.1.3
     task_body   9.1
     task_definition   9.1

identifier_extend
     identifier   2.3

identifier_letter
                                               2.1
     identifier   2.3
     identifier_start   2.3

identifier_start
     identifier   2.3

if_statement
     compound_statement   5.1

implicit_dereference
     prefix   4.1

incomplete_type_declaration
     type_declaration   3.2.1

index_constraint
     composite_constraint   3.2.2

index_subtype_definition
     unconstrained_array_definition   3.6

indexed_component
     name   4.1

integer_type_definition
     type_definition   3.2.1

interface_list
     derived_type_definition   3.4
     formal_derived_type_definition   12.5.1
     interface_type_definition   3.9.4
     private_extension_declaration   7.3
     protected_type_declaration   9.4
     single_protected_declaration   9.4
     single_task_declaration   9.1
     task_type_declaration   9.1

interface_type_definition
     formal_interface_type_definition   12.5.5
     type_definition   3.2.1

iteration_scheme
     loop_statement   5.5

known_discriminant_part
     discriminant_part   3.7
     full_type_declaration   3.2.1
     protected_type_declaration   9.4
     task_type_declaration   9.1

label
     statement   5.1

last_bit
     component_clause   13.5.1

letter_lowercase
     identifier_start   2.3

letter_modifier
     identifier_start   2.3

letter_or_digit
     identifier   2.3

letter_other
     identifier_start   2.3

letter_titlecase
     identifier_start   2.3

letter_uppercase
     identifier_start   2.3

library_item
     compilation_unit   10.1.1

library_unit_body
     library_item   10.1.1

library_unit_declaration
     library_item   10.1.1

library_unit_renaming_declaration
     library_item   10.1.1

limited_with_clause
     with_clause   10.1.2

local_name
     attribute_definition_clause   13.3
     component_clause   13.5.1
     enumeration_representation_clause   13.4
     record_representation_clause   13.5.1

loop_parameter_specification
     iteration_scheme   5.5

loop_statement
     compound_statement   5.1

mark_non_spacing
     identifier_extend   2.3

mark_spacing_combining
     identifier_extend   2.3

mod_clause
     record_representation_clause   13.5.1

mode
     formal_object_declaration   12.4
     parameter_specification   6.1

modular_type_definition
     integer_type_definition   3.5.4

multiplying_operator
     term   4.4

name
     abort_statement   9.8
     assignment_statement   5.2
     attribute_definition_clause   13.3
     default_name   12.6
     entry_call_statement   9.5.3
     exception_choice   11.2
     exception_renaming_declaration   8.5.2
     exit_statement   5.7
     explicit_actual_parameter   6.4
     explicit_dereference   4.1
     explicit_generic_actual_parameter   12.3
     formal_package_declaration   12.7
     function_call   6.4
     generic_instantiation   12.3
     generic_renaming_declaration   8.5.5
     goto_statement   5.8
     implicit_dereference   4.1
     limited_with_clause   10.1.2
     local_name   13.1
     nonlimited_with_clause   10.1.2
     object_renaming_declaration   8.5.1
     package_renaming_declaration   8.5.3
     parent_unit_name   10.1.1
     pragma_argument_association   2.8
     prefix   4.1
     primary   4.4
     procedure_call_statement   6.4
     raise_statement   11.3
     requeue_statement   9.5.4
     restriction_parameter_argument   13.12
     subprogram_renaming_declaration   8.5.4
     subtype_mark   3.2.2
     type_conversion   4.6
     use_package_clause   8.4
     with_clause   10.1.2

named_array_aggregate
     array_aggregate   4.3.3

nonlimited_with_clause
     with_clause   10.1.2

null_exclusion
     access_definition   3.10
     access_type_definition   3.10
     discriminant_specification   3.7
     formal_object_declaration   12.4
     object_renaming_declaration   8.5.1
     parameter_and_result_profile   6.1
     parameter_specification   6.1
     subtype_indication   3.2.2

null_procedure_declaration
     basic_declaration   3.1

null_statement
     simple_statement   5.1

number_decimal
     identifier_extend   2.3

number_declaration
     basic_declaration   3.1

number_letter
     identifier_start   2.3

numeral
     base   2.4.2
     decimal_literal   2.4.1
     exponent   2.4.1

numeric_literal
     primary   4.4

object_declaration
     basic_declaration   3.1

object_renaming_declaration
     renaming_declaration   8.5

operator_symbol
     defining_operator_symbol   6.1
     designator   6.1
     direct_name   4.1
     selector_name   4.1.3

ordinary_fixed_point_definition
     fixed_point_definition   3.5.9

other_control_function
                                               2.1

other_format
     identifier_extend   2.3

overriding_indicator
     abstract_subprogram_declaration   3.9.3
     entry_declaration   9.5.2
     generic_instantiation   12.3
     null_procedure_declaration   6.7
     subprogram_body   6.3
     subprogram_body_stub   10.1.3
     subprogram_declaration   6.1
     subprogram_renaming_declaration   8.5.4

package_body
     library_unit_body   10.1.1
     proper_body   3.11

package_body_stub
     body_stub   10.1.3

package_declaration
     basic_declaration   3.1
     library_unit_declaration   10.1.1

package_renaming_declaration
     library_unit_renaming_declaration   10.1.1
     renaming_declaration   8.5

package_specification
     generic_package_declaration   12.1
     package_declaration   7.1

parameter_and_result_profile
     access_definition   3.10
     access_to_subprogram_definition   3.10
     function_specification   6.1
     subprogram_specification   6.1

parameter_association
     actual_parameter_part   6.4

parameter_profile
     accept_statement   9.5.2
     access_definition   3.10
     access_to_subprogram_definition   3.10
     entry_body_formal_part   9.5.2
     entry_declaration   9.5.2
     procedure_specification   6.1
     subprogram_specification   6.1

parameter_specification
     formal_part   6.1

parent_unit_name
     defining_program_unit_name   6.1
     designator   6.1
     package_body   7.2
     package_specification   7.1
     subunit   10.1.3

position
     component_clause   13.5.1

positional_array_aggregate
     array_aggregate   4.3.3

pragma_argument_association
     pragma   2.8

prefix
     attribute_reference   4.1.4
     function_call   6.4
     indexed_component   4.1.1
     procedure_call_statement   6.4
     range_attribute_reference   4.1.4
     selected_component   4.1.3
     slice   4.1.2

primary
     factor   4.4

private_extension_declaration
     type_declaration   3.2.1

private_type_declaration
     type_declaration   3.2.1

procedure_call_statement
     procedure_or_entry_call   9.7.2
     simple_statement   5.1

procedure_or_entry_call
     entry_call_alternative   9.7.2
     triggering_statement   9.7.4

procedure_specification
     null_procedure_declaration   6.7
     subprogram_specification   6.1

proper_body
     body   3.11
     subunit   10.1.3

protected_body
     proper_body   3.11

protected_body_stub
     body_stub   10.1.3

protected_definition
     protected_type_declaration   9.4
     single_protected_declaration   9.4

protected_element_declaration
     protected_definition   9.4

protected_operation_declaration
     protected_definition   9.4
     protected_element_declaration   9.4

protected_operation_item
     protected_body   9.4

protected_type_declaration
     full_type_declaration   3.2.1

punctuation_connector
     identifier_extend   2.3

qualified_expression
     allocator   4.8
     code_statement   13.8
     primary   4.4

raise_statement
     simple_statement   5.1

range
     discrete_range   3.6.1
     discrete_subtype_definition   3.6
     range_constraint   3.5
     relation   4.4

range_attribute_designator
     range_attribute_reference   4.1.4

range_attribute_reference
     range   3.5

range_constraint
     delta_constraint   J.3
     digits_constraint   3.5.9
     scalar_constraint   3.2.2

real_range_specification
     decimal_fixed_point_definition   3.5.9
     floating_point_definition   3.5.7
     ordinary_fixed_point_definition   3.5.9

real_type_definition
     type_definition   3.2.1

record_aggregate
     aggregate   4.3

record_component_association
     record_component_association_list   4.3.1

record_component_association_list
     extension_aggregate   4.3.2
     record_aggregate   4.3.1

record_definition
     record_extension_part   3.9.1
     record_type_definition   3.8

record_extension_part
     derived_type_definition   3.4

record_representation_clause
     aspect_clause   13.1

record_type_definition
     type_definition   3.2.1

relation
     expression   4.4

relational_operator
     relation   4.4

renaming_declaration
     basic_declaration   3.1

representation_clause
     basic_declarative_item   3.11
     component_item   3.8
     protected_operation_declaration   9.4
     protected_operation_item   9.4
     task_item   9.1

requeue_statement
     simple_statement   5.1

restriction_parameter_argument
     restriction   13.12

return_statement
     simple_statement   5.1

return_subtype_indication
     extended_return_statement   6.5

scalar_constraint
     constraint   3.2.2

select_alternative
     selective_accept   9.7.1

select_statement
     compound_statement   5.1

selected_component
     name   4.1

selective_accept
     select_statement   9.7

selector_name
     component_choice_list   4.3.1
     discriminant_association   3.7.1
     formal_package_association   12.7
     generic_association   12.3
     parameter_association   6.4
     selected_component   4.1.3

sequence_of_statements
     abortable_part   9.7.4
     accept_alternative   9.7.1
     case_statement_alternative   5.4
     conditional_entry_call   9.7.3
     delay_alternative   9.7.1
     entry_call_alternative   9.7.2
     exception_handler   11.2
     handled_sequence_of_statements   11.2
     if_statement   5.3
     loop_statement   5.5
     selective_accept   9.7.1
     triggering_alternative   9.7.4

signed_integer_type_definition
     integer_type_definition   3.5.4

simple_expression
     first_bit   13.5.1
     last_bit   13.5.1
     range   3.5
     real_range_specification   3.5.7
     relation   4.4
     signed_integer_type_definition   3.5.4

simple_return_statement
     simple_statement   5.1

simple_statement
     statement   5.1

single_protected_declaration
     object_declaration   3.3.1

single_task_declaration
     object_declaration   3.3.1

slice
     name   4.1

space_character
                                               2.1

special_character
                                               2.1

statement
     sequence_of_statements   5.1

statement_identifier
     block_statement   5.6
     label   5.1
     loop_statement   5.5

string_element
     string_literal   2.6

string_literal
     operator_symbol   6.1
     primary   4.4

subprogram_body
     library_unit_body   10.1.1
     proper_body   3.11
     protected_operation_item   9.4

subprogram_body_stub
     body_stub   10.1.3

subprogram_declaration
     basic_declaration   3.1
     library_unit_declaration   10.1.1
     protected_operation_declaration   9.4
     protected_operation_item   9.4

subprogram_default
     formal_abstract_subprogram_declaration   12.6
     formal_concrete_subprogram_declaration   12.6
     formal_subprogram_declaration   12.6

subprogram_renaming_declaration
     library_unit_renaming_declaration   10.1.1
     renaming_declaration   8.5

subprogram_specification
                                               6.1
     abstract_subprogram_declaration   3.9.3
     formal_abstract_subprogram_declaration   12.6
     formal_concrete_subprogram_declaration   12.6
     formal_subprogram_declaration   12.6
     generic_subprogram_declaration   12.1
     subprogram_body   6.3
     subprogram_body_stub   10.1.3
     subprogram_declaration   6.1
     subprogram_renaming_declaration   8.5.4

subtype_declaration
     basic_declaration   3.1

subtype_indication
     access_to_object_definition   3.10
     allocator   4.8
     component_definition   3.6
     derived_type_definition   3.4
     discrete_range   3.6.1
     discrete_subtype_definition   3.6
     object_declaration   3.3.1
     private_extension_declaration   7.3
     return_subtype_indication   6.5
     subtype_declaration   3.2.2

subtype_mark
     access_definition   3.10
     ancestor_part   4.3.2
     discriminant_specification   3.7
     explicit_generic_actual_parameter   12.3
     formal_derived_type_definition   12.5.1
     formal_object_declaration   12.4
     index_subtype_definition   3.6
     interface_list   3.9.4
     object_renaming_declaration   8.5.1
     parameter_and_result_profile   6.1
     parameter_specification   6.1
     qualified_expression   4.7
     relation   4.4
     subtype_indication   3.2.2
     type_conversion   4.6
     use_type_clause   8.4

subunit
     compilation_unit   10.1.1

task_body
     proper_body   3.11

task_body_stub
     body_stub   10.1.3

task_definition
     single_task_declaration   9.1
     task_type_declaration   9.1

task_item
     task_definition   9.1

task_type_declaration
     full_type_declaration   3.2.1

term
     simple_expression   4.4

terminate_alternative
     select_alternative   9.7.1

timed_entry_call
     select_statement   9.7

triggering_alternative
     asynchronous_select   9.7.4

triggering_statement
     triggering_alternative   9.7.4

type_conversion
     name   4.1

type_declaration
     basic_declaration   3.1

type_definition
     full_type_declaration   3.2.1

unary_adding_operator
     simple_expression   4.4

unconstrained_array_definition
     array_type_definition   3.6

underline
     based_numeral   2.4.2
     identifier   2.3
     numeral   2.4.1

unknown_discriminant_part
     discriminant_part   3.7

use_clause
     basic_declarative_item   3.11
     context_item   10.1.2
     generic_formal_part   12.1

use_package_clause
     use_clause   8.4

use_type_clause
     use_clause   8.4

variant
     variant_part   3.8.1

variant_part
     component_list   3.8

with_clause
     context_item   10.1.2