Ada.bnf

{
    parserClass="org.nihlus.lace.language.parser.AdaParser"

    extends="com.intellij.extapi.psi.ASTWrapperPsiElement"

    psiClassPrefix="Ada"
    psiImplClassSuffix="Impl"
    psiPackage="org.nihlus.lace.language.psi"
    psiImplPackage="org.nihlus.lace.language.psi.Implementation"

    elementTypeHolderClass="org.nihlus.lace.language.psi.AdaTypes"
    elementTypeClass="org.nihlus.lace.language.psi.AdaElementType"
    tokenTypeClass="org.nihlus.lace.language.psi.AdaTokenType"

    tokens =
    [
        space = 'regexp:\s+'
        comment = 'regexp:--.*'

        NLS ='regexp:[ \t\f]*(\r|\n|\r\n)((\r|\n|\r\n)|([ \t\f])*)*'
        LF = 'regexp:(\r|\n|\r\n)+'

        // Keywords
        keyword_separate="separate"
        keyword_with="with"
	    keyword_use="use"
	    keyword_type="type"
	    keyword_private="private"
	    keyword_package="package"
	    keyword_renames="renames"
	    keyword_generic="generic"
	    keyword_procedure="procedure"
	    keyword_function="function"
	    keyword_is="is"
	    keyword_begin="begin"
	    keyword_end="end"
	    keyword_keyword_body="body"
	    keyword_task="task"
	    keyword_protected="protected"
	    keyword_entry="entry"
	    keyword_for="for"
	    keyword_when="when"
	    keyword_exception="exception"
	    keyword_others="others"
	    keyword_if="if"
	    keyword_then="then"
	    keyword_elsif="elsif"
	    keyword_else="else"
	    keyword_case="case"
	    keyword_while="while"
	    keyword_in="in"
	    keyword_reverse="reverse"
	    keyword_loop="loop"
	    keyword_declare="declare"
	    keyword_accept="accept"
	    keyword_do="do"
	    keyword_select="select"
	    keyword_or="or"
	    keyword_abort="abort"
	    keyword_terminate="terminate"
	    keyword_null="null"
	    keyword_exit="exit"
	    keyword_goto="goto"
	    keyword_return="return"
	    keyword_requeue="requeue"
	    keyword_delay="delay"
	    keyword_until="until"
	    keyword_raise="raise"
	    keyword_new="new"
	    keyword_abstract="abstract"
	    keyword_tagged="tagged"
	    keyword_limited="limited"
	    keyword_range="range"
	    keyword_mod="mod"
	    keyword_digits="digits"
	    keyword_delta="delta"
	    keyword_constant="constant"
	    keyword_subtype="subtype"
	    keyword_aliased="aliased"
	    keyword_at="at"
	    keyword_record="record"
	    keyword_access="access"
	    keyword_all="all"
	    keyword_array="array"
	    keyword_of="of"
	    keyword_out="out"

	    and="and"
	    xor="xor"
	    not="not"
	    rem="rem"
	    abs="abs"

	    equals="="
	    comma=","
        semicolon=";"
        fat_arrow="=>"
        colon=":"
        pipe="|"
        dot="."
        left_shift="<<"
        right_shift=">>"
        left_right_pointy_brackets="<>"
        assignment=":="
        single_quote="'"
        dotdot=".."
        not_equals="/="
        less_than="<"
        less_than_or_equal="<="
        greater_than=">"
        greater_than_or_equal=">="
        plus="+"
        minus="-"
        ampersand="&"
        asterisk="*"
        division="/"
        power="**"
        pound="#"
        underscore="_"

        SQBR_L='['
        SQBR_R=']'

        LP='('
        RP=')'

	    builtin_attribute_range="Range"
        builtin_attribute_access="Access"
        builtin_attribute_delta="Delta"
        builtin_attribute_digits="Digits"

		digit = "regexp:\d"
        number = "regexp:\d+"
        hex_number = "regexp:[a-f0-9]+"
        identifier = "regexp:[_a-zA-Z][a-zA-Z0-9_]+"

        string_literal = 'regexp:".*"'
        character_literal = "regexp:'[a-zA-Z ]'"
    ]
}

compilation_unit ::= context_clause (library_item | subunit)

subunit ::= 'separate' "(" parent_unit_name ")" proper_body

context_clause ::= { (with_clause | use_clause) }
with_clause ::= 'with' library_unit_name { ',' library_unit_name } ';'
use_clause ::= 'use' ((package_name { ',' package_name }) | ('type' subtype_mark { ',' subtype_mark })) ';'

library_item ::= [ 'private' ] library_unit_declaration | library_unit_body | [ 'private' ] library_unit_renaming_declaration
library_unit_renaming_declaration ::= package_renaming_declaration | generic_renaming_declaration | subprogram_renaming_declaration
package_renaming_declaration ::= 'package' defining_program_unit_name 'renames' element_name ';'
generic_renaming_declaration ::= 'generic' ( 'package' | 'procedure' | 'function' ) defining_program_unit_name 'renames' element_name ';'
subprogram_renaming_declaration ::= subprogram_specification 'renames' element_name ';'
library_unit_body ::= subprogram_body | package_body
subprogram_body ::= subprogram_specification 'is' declarative_part 'begin' handled_sequence_of_statements 'end' [ designator ] ';'
designator ::= [ parent_unit_name '.' ] ( identifier | operator_symbol )
declarative_part ::= { (basic_declarative_item | body ) }
body ::= proper_body | body_stub
body_stub ::= subprogram_body_stub | package_body_stub | task_body_stub | protected_body_stub
subprogram_body_stub ::= subprogram_specification 'is' 'separate' ';'
package_body_stub ::= 'package' 'body' defining_identifier 'is' 'separate' ';'
task_body_stub ::= 'task' 'body' defining_identifier 'is' 'separate' ';'
protected_body_stub ::= 'protected' 'body' defining_identifier 'is' 'separate' ';'
proper_body ::= subprogram_body | package_body | task_body | protected_body
task_body ::= 'task' 'body' defining_identifier 'is' declarative_part 'begin' handled_sequence_of_statements 'end' [ task_identifier ] ';'
protected_body ::= 'protected' 'body' defining_identifier 'is' { protected_operation_item } 'end' [ protected_identifier ] ';'
protected_operation_item ::= subprogram_declaration | subprogram_body | entry_body | representation_clause
entry_body ::= 'entry' defining_identifier entry_body_formal_part entry_barrier 'is' declarative_part 'begin' handled_sequence_of_statements 'end' [ entry_identifier ] ';'
entry_body_formal_part ::= [ "(" entry_index_specification ")" ] parameter_profile
entry_index_specification ::= 'for' defining_identifier 'in' discrete_subtype_definition
entry_barrier ::= 'when' condition
package_body ::= 'package' 'body' defining_program_unit_name 'is' declarative_part [ 'begin' handled_sequence_of_statements ] 'end' [ [ parent_unit_name '.' ] identifier ] ';'
handled_sequence_of_statements ::= sequence_of_statements [ 'exception' exception_handler { exception_handler } ]
exception_handler ::= 'when' [ choice_parameter_specification ':' ] exception_choice { '|'  exception_choice } '=>' sequence_of_statements
choice_parameter_specification ::= defining_identifier
exception_choice ::= exception_name | 'others'
sequence_of_statements ::= statement { statement }
statement ::= { label } ( simple_statement | compound_statement )
compound_statement ::= if_statement |
                       case_statement |
                       loop_statement |
                       block_statement |
                       accept_statement |
                       select_statement
if_statement ::= 'if' condition 'then' sequence_of_statements { 'elsif' condition 'then' sequence_of_statements } [ 'else' sequence_of_statements ] 'end' 'if' ';'
case_statement ::= 'case' expression 'is' case_statement_alternative { case_statement_alternative } 'end' 'case' ';'
case_statement_alternative ::= 'when' discrete_choice_list '=>' sequence_of_statements
loop_statement ::= [ statement_identifier ':' ]
                   [ ( 'while' condition ) | ( 'for' defining_identifier 'in' [ 'reverse' ] discrete_subtype_definition ) ]
                   'loop' sequence_of_statements 'end' 'loop' [ statement_identifier ] ';'
block_statement ::= [ statement_identifier ':' ] [ 'declare' declarative_part ] 'begin' handled_sequence_of_statements 'end' [ statement_identifier ] ';'
accept_statement ::= 'accept' direct_name [ "(" entry_index ")" ] parameter_profile [ 'do' handled_sequence_of_statements 'end' [ entry_identifier ] ] ';'
select_statement ::= selective_accept | timed_entry_call | conditional_entry_call | asynchronous_select
timed_entry_call ::= 'select' entry_call_alternative 'or' delay_alternative 'end' 'select' ';'
entry_call_alternative ::= entry_call_statement [ sequence_of_statements ]
conditional_entry_call ::= 'select' entry_call_alternative 'else' sequence_of_statements 'end' 'select' ';'
asynchronous_select ::= 'select' triggering_alternative 'then' 'abort' abortable_part 'end' 'select' ';'
triggering_alternative ::= triggering_statement [ sequence_of_statements ]
triggering_statement ::= entry_call_statement | delay_statement
abortable_part ::= sequence_of_statements
selective_accept ::= 'select' [ guard ] select_alternative { 'or' [ guard ] select_alternative } [ 'else' sequence_of_statements ] 'end' 'select' ';'
guard ::= 'when' condition '=>'
select_alternative ::= accept_alternative | delay_alternative | terminate_alternative
accept_alternative ::= accept_statement [ sequence_of_statements ]
delay_alternative ::= delay_statement [ sequence_of_statements ]
terminate_alternative ::= 'terminate' ';'
entry_index ::= expression
entry_identifier ::= identifier
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
null_statement ::= 'null' ';'
assignment_statement ::= variable_name value_assignment ';'
exit_statement ::= 'exit' [ loop_name ] [ 'when' condition ] ';'
goto_statement ::= 'goto' label_name ';'
procedure_call_statement ::= ( procedure_name | prefix ) [ actual_parameter_part ] ';'
return_statement ::= 'return' [ expression ] ';'
entry_call_statement ::= entry_name [ actual_parameter_part ] ';'
requeue_statement ::= 'requeue' entry_name [ 'with' 'abort' ] ';'
delay_statement ::= delay_until_statement | delay_relative_statement
delay_until_statement ::= 'delay' 'until' expression ';'
delay_relative_statement ::= 'delay' expression ';'
abort_statement ::= 'abort' task_name { ',' task_name } ';'
raise_statement ::= 'raise' [ exception_name ] ';'
code_statement ::= qualified_expression ';'
exception_name ::= element_name
task_name ::= element_name
label_name ::= element_name
loop_name ::= element_name
condition ::= expression
label ::= '<<' statement_identifier '>>'
statement_identifier ::= direct_name
library_unit_declaration ::= subprogram_declaration | package_declaration | generic_declaration | generic_instantiation
package_declaration ::= package_specification ';'
package_specification ::= 'package' defining_program_unit_name
                          'is' { basic_declarative_item } [ 'private' { basic_declarative_item } ]
                          'end' [[parent_unit_name '.'] identifier]
basic_declarative_item ::= basic_declaration | representation_clause | use_clause
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
generic_instantiation ::= ( 'package' defining_program_unit_name 'is' 'new' package_name [ generic_actual_part ] ';' ) |
                          ( 'procedure' defining_program_unit_name 'is' 'new' procedure_name [ generic_actual_part ] ';') |
                          ( 'function' defining_designator 'is' 'new' function_name [ generic_actual_part ] ';' )
generic_declaration ::= 'generic' { generic_formal_parameter_declaration | use_clause } ( subprogram_specification | package_specification ) ';'
generic_formal_parameter_declaration ::= formal_object_declaration | formal_type_declaration | formal_subprogram_declaration | formal_package_declaration
formal_package_declaration ::= 'with' 'package' defining_identifier 'is' 'new' package_name formal_package_actual_part ';'
formal_package_actual_part ::= "(" '<>' ")" | [ generic_actual_part ]
generic_actual_part ::= "(" generic_association { ',' generic_association } ")"
generic_association ::= [ selector_name '=>' ] expression | variable_name | procedure_name | function_name | entry_name | subtype_mark | package_name
variable_name ::= element_name
procedure_name ::= element_name
entry_name ::= element_name
formal_subprogram_declaration ::= 'with' subprogram_specification [ 'is' ( default_name | '<>' ) ] ';'
default_name ::= element_name
formal_object_declaration ::= defining_identifier_list ':' mode subtype_mark [ default_value_assignment ] ';'
formal_type_declaration ::= 'type' defining_identifier [ discriminant_part ] 'is' formal_type_definition ';'
formal_type_definition ::=
        formal_private_type_definition |
        formal_derived_type_definition |
        formal_discrete_type_definition |
        formal_signed_integer_type_definition |
        formal_modular_type_definition |
        formal_floating_point_definition |
        formal_ordinary_fixed_point_definition |
        formal_decimal_fixed_point_definition |
        formal_array_type_definition |
        formal_access_type_definition
formal_private_type_definition ::= [[ 'abstract' ] 'tagged' ] [ 'limited' ] 'private'
formal_derived_type_definition ::= [ 'abstract' ] 'new' subtype_mark [ 'with' 'private' ]
formal_discrete_type_definition ::= "(" '<>' ")"
formal_signed_integer_type_definition ::= 'range' '<>'
formal_modular_type_definition ::= 'mod' '<>'
formal_floating_point_definition ::= 'digits' '<>'
formal_ordinary_fixed_point_definition ::= 'delta' '<>'
formal_decimal_fixed_point_definition ::= 'delta' '<>' 'digits' '<>'
formal_array_type_definition ::= array_type_definition
formal_access_type_definition ::= access_type_definition
exception_declaration ::= defining_identifier_list ':' 'exception' ';'
abstract_subprogram_declaration ::= subprogram_specification 'is' 'abstract' ';'
renaming_declaration ::= (
                             (defining_identifier ':' subtype_mark ) |
                             ( defining_identifier ':' 'exception') |
                             ( 'package' defining_program_unit_name ) |
                             ( subprogram_specification ) |
                             ( 'generic' ( 'package' | 'procedure' | 'function') defining_program_unit_name )
                         ) 'renames' element_name ';'
number_declaration ::= defining_identifier_list ':' 'constant' value_assignment ';'
subtype_declaration ::= 'subtype' defining_identifier 'is' subtype_indication ';'
object_declaration ::= ( defining_identifier_list ':' [ 'aliased' ] [ 'constant' ] subtype_indication [ value_assignment ] ';' ) |
                       ( defining_identifier_list ':' [ 'aliased' ] [ 'constant' ] array_type_definition [ value_assignment ] ';' ) |
                       single_task_declaration |
                       single_protected_declaration
private value_assignment ::= ':=' expression
single_task_declaration ::= 'task' defining_identifier [ 'is' task_definition ] ';'
single_protected_declaration ::= 'protected' defining_identifier 'is' protected_definition ';'
type_declaration ::= full_type_declaration |
                     incomplete_type_declaration |
                     private_type_declaration |
                     private_extension_declaration
private_type_declaration ::= 'type' defining_identifier [ discriminant_part ] 'is' [ [ 'abstract' ] 'tagged' ] [ 'limited' ] 'private' ';'
private_extension_declaration ::= 'type' defining_identifier [ discriminant_part ] 'is' [ 'abstract' ] 'new' ancestor_subtype_indication 'with' 'private' ';'
ancestor_subtype_indication ::= subtype_indication
incomplete_type_declaration ::= 'type' defining_identifier [ discriminant_part ] ';'
discriminant_part ::= known_discriminant_part | ( "(" '<>' ")" )
full_type_declaration ::= ( 'type' defining_identifier [known_discriminant_part] 'is' type_definition ';') |
                          task_type_declaration |
                          protected_type_declaration
protected_type_declaration ::= 'protected' 'type' defining_identifier [ known_discriminant_part ] 'is' protected_definition ';'
protected_definition ::= { protected_operation_declaration } [ 'private' { protected_element_declaration } ] 'end' [ protected_identifier ]
protected_identifier ::= identifier
protected_operation_declaration ::= subprogram_declaration | entry_declaration | representation_clause
protected_element_declaration ::= protected_operation_declaration | component_declaration
component_declaration ::= defining_identifier_list ':' component_definition [ default_value_assignment ] ';'
private default_value_assignment ::= ':=' default_expression
component_definition ::= [ 'aliased' ] subtype_indication
task_type_declaration ::= 'task' 'type' defining_identifier [ known_discriminant_part ] [ 'is' task_definition ] ';'
task_definition ::= { task_item } [ 'private' { task_item } ] 'end' [ task_identifier ]
task_identifier ::= identifier
task_item ::= entry_declaration | representation_clause
representation_clause ::= attribute_definition_clause |
                          enumeration_representation_clause |
                          record_representation_clause |
                          at_clause
at_clause ::= 'for' direct_name 'use' 'at' expression ';'
record_representation_clause ::= 'for' first_subtype_local_name 'use' 'record' [ mod_clause ] { component_clause } 'end' 'record' ';'
mod_clause ::= 'at' 'mod' static_expression ';'
component_clause ::= local_name 'at' static_expression 'range' first_bit '..' last_bit ';'
last_bit ::= static_simple_expression
first_bit ::= static_simple_expression
static_simple_expression ::= simple_expression;
enumeration_representation_clause ::= 'for' first_subtype_local_name 'use' enumeration_aggregate ';'
first_subtype_local_name ::= direct_name
enumeration_aggregate ::= array_aggregate
attribute_definition_clause ::= 'for' local_name 'single_quote' attribute_designator 'use' expression ';' |
                                'for' local_name 'single_quote' attribute_designator 'use' element_name ';'
local_name ::= direct_name | direct_name 'single_quote' attribute_designator | library_unit_name
entry_declaration ::= 'entry' defining_identifier [ "(" discrete_subtype_definition ")" ] parameter_profile ';'
discrete_subtype_definition::= subtype_indication | range
parameter_profile ::= [ formal_part ]
type_definition ::= enumeration_type_definition |
                    integer_type_definition |
                    real_type_definition |
                    array_type_definition |
                    record_type_definition |
                    access_type_definition |
                    derived_type_definition
derived_type_definition ::= [ 'abstract' ] 'new' subtype_indication [ record_extension_part ]
record_extension_part ::= 'with' record_definition
access_type_definition ::= access_to_object_definition | access_to_subprogram_definition
access_to_object_definition ::= 'access' [ 'all' | 'constant' ] subtype_indication
access_to_subprogram_definition ::= ( 'access' [ 'protected' ] 'procedure' parameter_profile ) | ( 'access' [ 'protected' ] 'function' parameter_and_result_profile)
parameter_and_result_profile ::= [ formal_part ] 'return' subtype_mark
record_type_definition ::= [ [ 'abstract' ] 'tagged' ] [ 'limited' ] record_definition
record_definition ::= ( 'record' ( ( component_item { component_item } ) | ( { component_item } variant_part ) | ( 'null' ';' )) 'end' 'record') | ( 'null' 'record' )
component_item ::= component_declaration | representation_clause
variant_part ::= 'case' direct_name 'is' variant { variant } 'end' 'case' ';'
variant ::= 'when' discrete_choice_list '=>' ( component_item { component_item } ) | ( { component_item } variant_part ) | ( 'null' ';' )
array_type_definition ::= unconstrained_array_definition | constrained_array_definition
unconstrained_array_definition ::= 'array' "(" index_subtype_definition { ',' index_subtype_definition } ")" 'of' component_definition
constrained_array_definition ::= 'array' "(" discrete_subtype_definition { ',' discrete_subtype_definition } ")" 'of' component_definition
index_subtype_definition ::= subtype_mark range '<>'
real_type_definition ::= floating_point_definition | ordinary_fixed_point_definition | decimal_fixed_point_definition
floating_point_definition ::= 'digits' expression [ simple_range_definition ]
ordinary_fixed_point_definition ::= 'delta' expression simple_range_definition
private simple_range_definition ::= 'range' simple_expression '..' simple_expression
decimal_fixed_point_definition ::= 'delta' expression 'digits' expression [ simple_range_definition ]
integer_type_definition ::= ( simple_range_definition ) | ( 'mod' expression )
enumeration_type_definition ::= "(" enumeration_literal_specification { ',' enumeration_literal_specification } ")"
enumeration_literal_specification ::= defining_identifier | 'character_literal'
known_discriminant_part ::= "(" discriminant_specification { ';' discriminant_specification } ")"
discriminant_specification ::= defining_identifier_list ':' subtype_mark [ default_value_assignment ] |
                               defining_identifier_list ':' access_definition [ default_value_assignment]
subprogram_declaration ::= subprogram_specification ';'
subprogram_specification ::= ('procedure' defining_program_unit_name [ formal_part ]) |
                             ('function' defining_designator [ formal_part ] 'return' subtype_mark)
defining_designator ::= defining_program_unit_name | defining_operator_symbol
defining_operator_symbol ::= operator_symbol
formal_part ::= "(" parameter_specification { ';'  parameter_specification } ")"
parameter_specification ::= defining_identifier_list ':' ((mode subtype_mark) | access_definition) [ default_value_assignment]
defining_identifier_list ::= defining_identifier { ',' defining_identifier }
mode ::= ( 'in' 'out' ) | ( 'out' ) | [ 'in' ]
access_definition ::= 'access' subtype_mark
default_expression ::= expression
defining_program_unit_name ::= [ parent_unit_name '.' ] defining_identifier
parent_unit_name ::= element_name
defining_identifier ::= identifier
package_name ::= element_name
library_unit_name ::= element_name
element_name ::= direct_name |
         slice |
         selected_component |
         attribute_reference |
         type_conversion |
         function_call |
         'character_literal' |
         explicit_dereference |
         indexed_component

function_call ::= (function_name | prefix) [ actual_parameter_part ]
function_name ::= element_name
type_conversion ::= subtype_mark "(" (expression | element_name) ")"
attribute_reference ::= prefix 'single_quote' attribute_designator
selected_component ::= prefix '.' selector_name
slice ::= prefix "(" discrete_range ")"
explicit_dereference ::= element_name '.' 'all'
indexed_component ::= prefix "(" expression { ',' expression } ")"
prefix ::= element_name
subtype_mark ::= element_name

attribute_designator ::= (identifier [ "(" expression ")" ]) | 'Access' | 'Delta' | 'Digits'
direct_name ::= identifier | operator_symbol

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

actual_parameter_part ::= "(" parameter_association { ',' parameter_association } ")"
parameter_association ::= [ selector_name '=>' ] ( expression | element_name )

relation ::= (simple_expression [( '=' | '/=' | '<' | '<=' | '>' | '>=' ) simple_expression]) |
             (simple_expression [ 'not'] 'in' (range | subtype_mark))
simple_expression ::= [('+' '-')] term { ('+' | '-' | '&') term }

term ::= factor { ( '*' | '/' | 'mod' | 'rem' ) factor }
factor ::= (primary [ '**' primary]) | ('abs' primary) | ('not' primary)

primary ::= numeric_literal |
            'null' |
            'string_literal' |
            aggregate |
            element_name |
            qualified_expression |
            allocator |
            ("(" expression ")")

allocator ::= 'new' (subtype_indication | qualified_expression)
qualified_expression ::= subtype_mark 'single_quote' (( "(" expression ")" ) | aggregate)
aggregate ::= record_aggregate | extension_aggregate | array_aggregate
array_aggregate ::= positional_array_aggregate | named_array_aggregate
positional_array_aggregate ::= ( "(" expression ',' expression { ',' expression } ")") |
                               ( "(" expression { ',' expression } ',' 'others' '=>' expression ")")
named_array_aggregate ::= "(" array_component_association { ',' array_component_association } ")"
array_component_association ::= discrete_choice_list '=>' expression
discrete_choice_list ::= discrete_choice { '|' discrete_choice }
discrete_choice ::= expression | discrete_range | 'others'
discrete_range ::= subtype_indication | range
subtype_indication ::= subtype_mark [ constraint ]
constraint ::= range_constraint | digits_constraint | delta_constraint | index_constraint | discriminant_constraint
discriminant_constraint ::= "(" discriminant_association { ',' discriminant_association } ")"
discriminant_association ::= [ selector_name { '|' selector_name } '=>' ] expression
index_constraint ::= "(" discrete_range { ',' discrete_range } ")"
delta_constraint ::= 'delta' static_expression [ range_constraint ]
static_expression ::= expression
digits_constraint ::= 'digits' expression [ range_constraint ]
range_constraint ::= 'range' range
range ::= range_attribute_reference | (simple_expression '..' simple_expression)
range_attribute_reference ::= prefix 'single_quote' range_attribute_designator
range_attribute_designator ::= 'Range' [ "(" expression ")" ]
extension_aggregate ::= "(" ancestor_part 'with'
                        (
                            (record_component_association { ',' record_component_association}) |
                            ( 'null' 'record' )
                        ) ")"
ancestor_part ::= expression | subtype_mark

record_aggregate ::= "(" (record_component_association { ',' record_component_association }) | ( 'null' 'record' ) ")"
record_component_association ::= [ component_choice_list '=>' ] expression
component_choice_list ::= (selector_name { '|' selector_name }) | 'others'
selector_name ::= identifier | 'character_literal' | operator_symbol
numeric_literal ::= decimal_literal | based_literal
decimal_literal ::= numeral [ '.' numeral ] [ exponent ]
based_literal ::= base '#' based_numeral [ '.' based_numeral ] '#' [ exponent ]
base ::= numeral
based_numeral ::= extended_digit { [ '_' ] extended_digit }
extended_digit ::= digit | "A" | "B" | "C" | "D" | "E" | "F"
numeral ::= digit { [ '_' ] digit}
exponent ::= ("E" ['+'] numeral) | ("E" ['-'] numeral)
operator_symbol ::= 'string_literal'