ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/MISC/ADA_LRM1.ZIP/CHAPE.DOC

Text File | 1988-11-30 | 19.1 KB | 926 lines

                             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



                                   E - 1








    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




                                   E - 2








    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




                                   E - 3








    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})




                                   E - 4








    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



                                   E - 5








    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)


                                   E - 6








    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;


                                   E - 7








    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




                                   E - 8








    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})




                                   E - 9








    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


                                  E - 10








          {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


                                  E - 11








    accept_alternative  ::=
       accept_statement [sequence_of_statements]

    delay_alternative  ::=
       delay_statement [sequence_of_statements]

    terminate_alternative ::= terminate;

    9.7.2

    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};


                                  E - 12








    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];


                                  E - 13








    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;





                                  E - 14