

                                   Annex P
                                (informative)

                               Syntax Summary


This Annex summarizes the complete syntax of the language. See 1.1.4 for a
description of the notation used.

      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_letter {[underline] letter_or_digit}

      2.3:
      letter_or_digit::= identifier_letter | digit

      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.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
         | 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

      3.2.2:
      subtype_declaration::= 
         subtype defining_identifier is subtype_indication;

      3.2.2:
      subtype_indication::=  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] 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] new parent_subtype_indication
       [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

      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 : 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

      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.10:
      access_type_definition::= 
          access_to_object_definition
        | 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:
      access_definition::= access subtype_mark

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

      3.11:
      declarative_part::= {declarative_item}

      3.11:
      declarative_item::= 
          basic_declarative_item | body

      3.11:
      basic_declarative_item::= 
          basic_declaration | aspect_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

      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)

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

      4.3.3:
      array_component_association::= 
          discrete_choice_list => expression

      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
         | 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
         | 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::= subprogram_specification;

      6.1:
      abstract_subprogram_declaration::= subprogram_specification is abstract;

      6.1:
      subprogram_specification::= 
           procedure defining_program_unit_name  parameter_profile
         | 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 subtype_mark

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

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

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

      6.3:
      subprogram_body::= 
          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:
      return_statement::= return [expression];

      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] new ancestor_subtype_indication with private;

      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 : subtype_mark
       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::= 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 task_definition];

      9.1:
      single_task_declaration::= 
         task defining_identifier [is task_definition];

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

      9.1:
      task_item::= entry_declaration | aspect_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 protected_definition;

      9.4:
      single_protected_declaration::= 
        protected defining_identifier is 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

      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

      9.5.2:
      entry_declaration::= 
         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::= 
        entry_call_statement [sequence_of_statements]

      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::= 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::= 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::= 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 [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];
         | procedure defining_program_unit_name is
               new generic_procedure_name [generic_actual_part];
         | 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 subtype_mark
       [:= 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

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

      12.5.1:
      formal_derived_type_definition::= [abstract] new subtype_mark
       [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.6:
      formal_subprogram_declaration::= with subprogram_specification
       [is subprogram_default];

      12.6:
      subprogram_default::= default_name | <>

      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::= 
          (<>) | [generic_actual_part]

      13.1:
      aspect_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 => 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;



Syntax Cross Reference



      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
          discriminant_specification                3.7
          parameter_specification                   6.1

      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
          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
          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
          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
          extended_digit                            2.4.2
          graphic_character                         2.1
          letter_or_digit                           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
          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
          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
          range_attribute_designator                4.1.4
          record_component_association              4.3.1
          restriction                               13.12
          return_statement                          6.5
          type_conversion                           4.6

      extended_digit
          based_numeral                             2.4.2

      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_access_type_definition
          formal_type_definition                    12.5

      formal_array_type_definition
          formal_type_definition                    12.5

      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_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_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
          character                                 2.1

      full_type_declaration
          type_declaration                          3.2.1

      function_call
          name                                      4.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
          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
          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
          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_letter
          graphic_character                         2.1
          identifier                                2.3
          letter_or_digit                           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

      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_or_digit
          identifier                                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

      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

      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
          local_name                                13.1
          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
          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

      null_statement
          simple_statement                          5.1

      number_declaration
          basic_declaration                         3.1

      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
          character                                 2.1

      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_to_subprogram_definition           3.10
          subprogram_specification                  6.1

      parameter_association
          actual_parameter_part                     6.4

      parameter_profile
          accept_statement                          9.5.2
          access_to_subprogram_definition           3.10
          entry_body_formal_part                    9.5.2
          entry_declaration                         9.5.2
          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
          simple_statement                          5.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

      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

      requeue_statement
          simple_statement                          5.1

      return_statement
          simple_statement                          5.1

      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
          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_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
          graphic_character                         2.1

      special_character
          graphic_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_subprogram_declaration             12.6

      subprogram_renaming_declaration
          library_unit_renaming_declaration         10.1.1
          renaming_declaration                      8.5

      subprogram_specification
          abstract_subprogram_declaration           6.1
          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
          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
          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

