E. Syntax Summary

    2.1 

    graphic_character ::= basic_graphic_character
       | lower_case_letter | other_special_character 

    basic_graphic_character ::=
         upper_case_letter | digit
       | special_character | space_character 

    basic_character ::=
         basic_graphic_character | format_effector 

    2.3 

    identifier ::=
       letter {[underline] letter_or_digit} 

    letter_or_digit ::= letter | digit 

    letter ::= upper_case_letter | lower_case_letter 

    2.4 

    numeric_literal ::= decimal_literal | based_literal 

    2.4.1 

    decimal_literal ::= integer [.integer] [exponent] 

    integer ::= digit {[underline] digit} 

    exponent ::= E [+] integer | E - integer 

    2.4.2 

    based_literal ::=
       base # based_integer [.based_integer] # [exponent] 

    base ::= integer 

    based_integer ::=
       extended_digit {[underline] extended_digit} 

    extended_digit ::= digit | letter   

    2.5 

    character_literal ::= 'graphic_character' 

    2.6 

    string_literal ::= "{graphic_character}" 

    2.8 

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

    argument_association ::=
         [argument_identifier =>] name
       | [argument_identifier =>] expression 

    3.1 

    basic_declaration ::=
         object_declaration     | number_declaration
       | type_declaration       | subtype_declaration
       | subprogram_declaration | package_declaration
       | task_declaration       | generic_declaration
       | exception_declaration  | generic_instantiation 
       | renaming_declaration   | deferred_constant_declaration 

    3.2 

    object_declaration ::=
         identifier_list : [constant] subtype_indication [:= expression];
       | identifier_list : [constant] constrained_array_definition
                                                         [:= expression]; 

    number_declaration ::=
         identifier_list : constant := universal_static_expression; 

    identifier_list ::=  identifier {, identifier} 

    3.3.1 

    type_declaration ::=  full_type_declaration
       | incomplete_type_declaration | private_type_declaration 

    full_type_declaration ::=
     type identifier [discriminant_part] is type_definition; 

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

    3.3.2 

    subtype_declaration ::=
       subtype identifier is subtype_indication; 

    subtype_indication ::=  type_mark [constraint] 

    type_mark ::= type_name | subtype_name 

    constraint ::=
         range_constraint       | floating_point_constraint
       | fixed_point_constraint | index_constraint
       | discriminant_constraint 

    3.4 

    derived_type_definition ::= new subtype_indication 

    3.5 

    range_constraint ::=  range range 

    range ::=  range_attribute
       | simple_expression .. simple_expression 

    3.5.1 

    enumeration_type_definition ::=
       (enumeration_literal_specification
          {, enumeration_literal_specification}) 

    enumeration_literal_specification ::=  enumeration_literal 

    enumeration_literal ::=  identifier | character_literal 

    3.5.4    

    integer_type_definition ::=  range_constraint 

    3.5.6 

    real_type_definition ::=
       floating_point_constraint | fixed_point_constraint 

    3.5.7 

    floating_point_constraint ::=
       floating_accuracy_definition [range_constraint] 

    floating_accuracy_definition ::=
       digits static_simple_expression 

    3.5.9    

    fixed_point_constraint ::=
       fixed_accuracy_definition [range_constraint] 

    fixed_accuracy_definition ::=
       delta static_simple_expression 

    3.6 

    array_type_definition ::=
       unconstrained_array_definition | constrained_array_definition 

    unconstrained_array_definition ::=
       array(index_subtype_definition {, index_subtype_definition}) of
                component_subtype_indication 

    constrained_array_definition ::=
       array index_constraint of component_subtype_indication 

    index_subtype_definition ::= type_mark range <> 

    index_constraint ::=  (discrete_range {, discrete_range}) 

    discrete_range ::= discrete_subtype_indication | range 

    3.7 

    record_type_definition ::=
       record
          component_list
       end record 

    component_list ::=
          component_declaration {component_declaration}
       | {component_declaration} variant_part
       |  null; 

    component_declaration ::=
       identifier_list : component_subtype_definition [:= expression]; 

    component_subtype_definition ::=  subtype_indication 

    3.7.1 

    discriminant_part ::=
       (discriminant_specification {; discriminant_specification}) 

    discriminant_specification ::=
       identifier_list : type_mark [:= expression] 

    3.7.2 

    discriminant_constraint ::=
       (discriminant_association {, discriminant_association})       

    discriminant_association ::=
       [discriminant_simple_name {| discriminant_simple_name} =>]
                expression 

    3.7.3 

    variant_part ::=
       case discriminant_simple_name is
           variant
          {variant}
       end case; 

    variant ::=
       when choice {| choice} =>
          component_list 

    choice ::= simple_expression
       | discrete_range | others | component_simple_name 

    3.8 

    access_type_definition ::= access subtype_indication 

    3.8.1 

    incomplete_type_declaration ::=
       type identifier [discriminant_part]; 

    3.9 

    declarative_part ::=
       {basic_declarative_item} {later_declarative_item} 

    basic_declarative_item ::= basic_declaration
       | representation_clause | use_clause 

    later_declarative_item ::= body
       | subprogram_declaration | package_declaration
       | task_declaration       | generic_declaration
       | use_clause             | generic_instantiation 

    body ::= proper_body | body_stub 

    proper_body ::=
       subprogram_body | package_body | task_body 

    4.1 

    name ::= simple_name
       | character_literal  | operator_symbol
       | indexed_component  | slice
       | selected_component | attribute 

    simple_name ::= identifier   

    prefix ::= name | function_call 

    4.1.1 

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

    4.1.2 

    slice ::= prefix(discrete_range) 

    4.1.3 

    selected_component ::= prefix.selector 

    selector ::= simple_name
       | character_literal | operator_symbol | all 

    4.1.4 

    attribute ::= prefix'attribute_designator 

    attribute_designator ::=  
       simple_name [(universal_static_expression)] 

    4.3 

    aggregate ::=
       (component_association {, component_association}) 

    component_association ::=
       [choice {| choice} => ] expression 

    4.4 

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

    relation ::=
         simple_expression [relational_operator simple_expression]
       | simple_expression [not] in range
       | simple_expression [not] in type_mark 

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

    term ::= factor {multiplying_operator factor} 

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

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

    4.5 

    logical_operator  ::=  and | or | xor 

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

    binary_adding_operator  ::=  + | - | & 

    unary_adding_operator  ::=  + | - 

    multiplying_operator  ::=  * | / | mod | rem 

    highest_precedence_operator  ::=  ** | abs | not 

    4.6 

    type_conversion ::= type_mark(expression) 

    4.7 

    qualified_expression ::=
       type_mark'(expression) | type_mark'aggregate 

    4.8 

    allocator ::=
       new subtype_indication | new qualified_expression 

    5.1 

    sequence_of_statements ::= statement {statement} 

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

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

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

    label ::= <> 

    null_statement ::= null; 

    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; 

    condition ::= boolean_expression 

    5.4 

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

    case_statement_alternative ::=
       when choice {| choice } =>
          sequence_of_statements 

    5.5 

    loop_statement ::=
       [loop_simple_name:]
          [iteration_scheme] loop
             sequence_of_statements
           end loop [loop_simple_name]; 

    iteration_scheme ::= while condition
       | for loop_parameter_specification 

    loop_parameter_specification ::=
       identifier in [reverse] discrete_range 

    5.6 

    block_statement ::=
       [block_simple_name:]
          [declare
               declarative_part]
           begin
               sequence_of_statements
          [exception
               exception_handler
              {exception_handler}]
           end [block_simple_name]; 

    5.7    

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

    5.8 

    return_statement ::= return [expression]; 

    5.9 

    goto_statement ::= goto label_name; 

    6.1 

    subprogram_declaration ::= subprogram_specification; 

    subprogram_specification ::=
         procedure identifier [formal_part]
       | function designator  [formal_part] return type_mark 

    designator ::= identifier | operator_symbol 

    operator_symbol ::= string_literal 

    formal_part ::=
       (parameter_specification {; parameter_specification}) 

    parameter_specification ::=
       identifier_list : mode type_mark [:= expression] 

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

    6.3 

    subprogram_body ::=
        subprogram_specification is
           [declarative_part]
        begin
            sequence_of_statements
       [exception
            exception_handler
           {exception_handler}]
        end [designator]; 

    6.4 

    procedure_call_statement ::=
       procedure_name [actual_parameter_part]; 

    function_call ::=
       function_name [actual_parameter_part] 

    actual_parameter_part ::=
       (parameter_association {, parameter_association})    

    parameter_association ::=
       [formal_parameter =>] actual_parameter 

    formal_parameter ::= parameter_simple_name 

    actual_parameter ::=
       expression | variable_name | type_mark(variable_name) 

    7.1 

    package_declaration ::= package_specification; 

    package_specification ::=
        package identifier is
          {basic_declarative_item}
       [private
          {basic_declarative_item}]
        end [package_simple_name] 

    package_body ::=
        package body package_simple_name is
           [declarative_part] 
       [begin
            sequence_of_statements
       [exception
            exception_handler
           {exception_handler}]]
        end [package_simple_name]; 

    7.4 

    private_type_declaration ::=
       type identifier [discriminant_part] is [limited] private; 

    deferred_constant_declaration ::=
       identifier_list : constant type_mark; 

    8.4 

    use_clause ::= use package_name {, package_name}; 

    8.5 

    renaming_declaration ::=
         identifier : type_mark   renames object_name;
       | identifier : exception   renames exception_name;
       | package identifier       renames package_name;
       | subprogram_specification renames subprogram_or_entry_name; 

    9.1 

    task_declaration ::= task_specification; 

    task_specification ::=
       task [type] identifier [is  
          {entry_declaration}
          {representation_clause}
       end [task_simple_name]] 

    task_body ::=
        task body task_simple_name is
           [declarative_part]
        begin
            sequence_of_statements
       [exception
            exception_handler
           {exception_handler}]
        end [task_simple_name]; 

    9.5 

    entry_declaration ::=
       entry identifier [(discrete_range)] [formal_part]; 

    entry_call_statement ::=
       entry_name [actual_parameter_part]; 

    accept_statement ::=
       accept entry_simple_name [(entry_index)] [formal_part] [do
          sequence_of_statements
       end [entry_simple_name]]; 

    entry_index ::= expression 

    9.6 

    delay_statement ::= delay simple_expression; 

    9.7 

    select_statement ::= selective_wait
       | conditional_entry_call | timed_entry_call 

    9.7.1 

    selective_wait ::=
        select   
          select_alternative
       {or
          select_alternative}
       [else
          sequence_of_statements]
        end select; 

    select_alternative ::=
       [when condition =>]
          selective_wait_alternative 

    selective_wait_alternative ::= accept_alternative
       | delay_alternative | terminate_alternative  

    accept_alternative  ::=
       accept_statement [sequence_of_statements] 

    delay_alternative  ::=
       delay_statement [sequence_of_statements] 

    terminate_alternative ::= terminate; 

    conditional_entry_call ::=
       select
           entry_call_statement
          [sequence_of_statements]
       else
           sequence_of_statements
       end select; 

    9.7.3 

    timed_entry_call ::=
       select
           entry_call_statement
          [sequence_of_statements]
       or
           delay_alternative
       end select; 

    9.10

    abort_statement ::= abort task_name {, task_name}; 

    10.1 

    compilation ::= {compilation_unit} 

    compilation_unit ::=
         context_clause library_unit
       | context_clause secondary_unit 

    library_unit ::=
         subprogram_declaration | package_declaration
       | generic_declaration    | generic_instantiation
       | subprogram_body 

    secondary_unit ::= library_unit_body | subunit 

    library_unit_body ::= subprogram_body | package_body 

    10.1.1 

    context_clause ::= {with_clause {use_clause}} 

    with_clause ::=
       with unit_simple_name {, unit_simple_name};  

    10.2 

    body_stub ::=
         subprogram_specification is separate;
       | package body package_simple_name is separate;
       | task body task_simple_name is separate; 

    subunit ::= separate (parent_unit_name) proper_body 

    11.1 

    exception_declaration ::= identifier_list : exception; 

    11.2 

    exception_handler ::=
       when exception_choice {| exception_choice} =>
          sequence_of_statements 

    exception_choice ::= exception_name | others 

    11.3 

    raise_statement ::= raise [exception_name]; 

    12.1 

    generic_declaration ::= generic_specification; 

    generic_specification ::=
         generic_formal_part subprogram_specification
       | generic_formal_part package_specification 

    generic_formal_part ::= generic {generic_parameter_declaration} 

    generic_parameter_declaration ::=
         identifier_list : [in [out]] type_mark [:= expression];
       | type identifier is generic_type_definition;
       | private_type_declaration
       | with subprogram_specification [is name];
       | with subprogram_specification [is <>]; 

    generic_type_definition ::=
         (<>) | range <> | digits <> | delta <>
       | array_type_definition | access_type_definition 

    12.3 

    generic_instantiation ::=
         package identifier is
             new generic_package_name [generic_actual_part];
       | procedure identifier is
             new generic_procedure_name [generic_actual_part];
       | function designator is
             new generic_function_name [generic_actual_part];  

    generic_actual_part ::=
       (generic_association {, generic_association}) 

    generic_association ::=
       [generic_formal_parameter =>] generic_actual_parameter

    generic_formal_parameter ::=
       parameter_simple_name | operator_symbol 

    generic_actual_parameter ::= expression | variable_name  
       | subprogram_name | entry_name | type_mark 

    13.1 

    representation_clause ::=
         type_representation_clause | address_clause 

    type_representation_clause ::= length_clause
       | enumeration_representation_clause
       | record_representation_clause 

    13.2 

    length_clause ::= for attribute use simple_expression; 

    13.3 

    enumeration_representation_clause ::=
       for type_simple_name use aggregate; 

    13.4 

    record_representation_clause ::=
       for type_simple_name use
          record [alignment_clause]
             {component_clause}
          end record; 

    alignment_clause ::= at mod static_simple_expression; 

    component_clause ::=
       component_name at static_simple_expression
                      range static_range; 

    13.5 

    address_clause ::=
       for simple_name use at simple_expression; 

    13.8 

    code_statement ::= type_mark'record_aggregate;