The Ada Joint Program Office does not guarantee the accuracy of this
file, as compared with the contents of ANSI/MIL-STD-1815A-1983,
the Reference Manual for the Ada Programming Language.  If errors or
discrepancies are found in this machine-readable version, please 
forward comments via the Defense Data Network (DDN) to:

                     ACTION@AJPO.SEI.CMU.EDU

or via conventional mail to

                  Ada Information Clearinghouse
                   3D139 (1211 S. Fern, C-107)
                         The Pentagon
                   Washington, D.C.  20301-3081

-----------------------------------------------------------------------

Copyright 1980, 1982, 1983 owned by the United States Government as
represented by the Under Secretary of Defense, Research and
Engineering.  All rights reserved.  Provided that notice of copyright
is included on the first page, this document may be copied in its
entirety without alteration or as altered by (1) adding text that is
clearly marked as an insertion; (2) shading or highlighting existing
text; (3) deleting examples.  Permission to publish other excerpts
should be obtained from the Ada Joint Program Office, OUSDRE (R&AT),
The Pentagon, Washington, DC 20301-2081, U.S.A.






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

    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;