path: root/languages/ada/ada.tree.g

/*
 * ANTLR Ada95 tree super grammar (base class)
 *
 * Oliver M. Kellogg  <okellogg@users.sourceforge.net>
 *
 * $Id$
 *
 */


options {
  language="Cpp";
}

class AdaTreeParserSuper extends TreeParser;
options {
  importVocab=Ada;
}

// Compilation Unit:  This is the start rule.

compilation_unit
	: context_items_opt ( library_item | subunit ) ( pragma )*
	;

pragma  : #(PRAGMA IDENTIFIER ( pragma_arg )* )
	;

pragma_arg
	: #(RIGHT_SHAFT IDENTIFIER expression)
	| expression
	;

context_items_opt
	: #(CONTEXT_CLAUSE ( pragma | with_clause | use_clause )* )
	;

with_clause
	: #(WITH_CLAUSE ( compound_name )+ )
	;

compound_name
	: IDENTIFIER
	| #(DOT compound_name IDENTIFIER)
	;

use_clause
	: #(USE_TYPE_CLAUSE ( subtype_mark )+ )
	| #(USE_CLAUSE ( compound_name )+ )
	;

subtype_mark
	: compound_name
	| #(TIC compound_name attribute_id)
	;

attribute_id : RANGE
	| DIGITS
	| DELTA
	| ACCESS
	| IDENTIFIER
	;

library_item :
	#(LIBRARY_ITEM modifiers
		( subprog_decl_or_rename_or_inst_or_body
		| #(PACKAGE_BODY def_id pkg_body_part)
		| #(GENERIC_PACKAGE_INSTANTIATION def_id generic_inst)
		| #(PACKAGE_SPECIFICATION def_id pkg_spec_part)
		| #(PACKAGE_RENAMING_DECLARATION def_id renames)
		| generic_decl
		)
	)
	;

modifiers : #(MODIFIERS
		( ABSTRACT
		| ACCESS
		| ALIASED
		| ALL
		| CONSTANT
		| IN
                | LIMITED
		| OUT
		| PRIVATE
		| PROTECTED
		| REVERSE
		| TAGGED
		)*
		// We can afford to be this loose because the parser
		// has already fended off illegal usages, i.e. we can
		// be sure that we are only dealing with permissible
		// values for each usage context here.
		// Only exception: PRIVATE as the prefix of private
		// {generic|package|subprogram} library-level decl.
		// The parser has let this in for bodies as well
		// (which is not legal), so we need a semantic check.
	     )
	;

id_opt : #(ID_OPT ( def_designator )? )
	;

end_id_opt : #(END ( def_designator )? )
	;

subprog_decl
	: #(GENERIC_PROCEDURE_INSTANTIATION def_id generic_inst)
	| #(PROCEDURE_RENAMING_DECLARATION  def_id formal_part_opt renames)
	| #(PROCEDURE_DECLARATION           def_id formal_part_opt)
	| #(PROCEDURE_BODY_STUB             def_id formal_part_opt)
	| #(ABSTRACT_PROCEDURE_DECLARATION  def_id formal_part_opt)
	| #(GENERIC_FUNCTION_INSTANTIATION  def_designator generic_inst)
	| #(FUNCTION_RENAMING_DECLARATION   def_designator function_tail renames)
	| #(FUNCTION_DECLARATION            def_designator function_tail)
	| #(FUNCTION_BODY_STUB              def_designator function_tail)
	| #(ABSTRACT_FUNCTION_DECLARATION   def_id function_tail)
	;

def_id : compound_name  // Can afford looseness because parser is tight.
	;

generic_inst : compound_name ( value_s )?
	;

value   : #(OTHERS expression)
	| #(RIGHT_SHAFT ranged_expr_s expression)
	| ranged_expr_s
	;

ranged_expr_s
	: #(PIPE ranged_expr_s ranged_expr)
	| ranged_expr
	;

ranged_expr
	: #(DOT_DOT expression simple_expression)
	| #(RANGE expression range)
	| expression
	;

range_constraint : #(RANGE_CONSTRAINT range)
	;

range : ( range_dots
	| range_attrib_ref
	)
	;

range_dots : #(DOT_DOT simple_expression simple_expression)
	;

range_attrib_ref : #(RANGE_ATTRIBUTE_REFERENCE prefix ( expression )? )
	;

prefix  : IDENTIFIER
	| #(DOT prefix ( ALL | IDENTIFIER ) )
	| #(INDEXED_COMPONENT prefix value_s )
	;

formal_part_opt : #(FORMAL_PART_OPT ( parameter_specification )* )
	;

parameter_specification
	: #(PARAMETER_SPECIFICATION defining_identifier_list modifiers
		subtype_mark init_opt)
	;

defining_identifier_list : #(DEFINING_IDENTIFIER_LIST ( IDENTIFIER )+ )
	;

renames : CHARACTER_STRING  // CHARACTER_STRING should not really be there.
	| OPERATOR_SYMBOL   // OPERATOR_SYMBOL should be used instead.
	| name
	;

name    : IDENTIFIER
	| #(DOT name
		( ALL
		| IDENTIFIER
		| CHARACTER_LITERAL
		| OPERATOR_SYMBOL
		)
	   )
	| #(INDEXED_COMPONENT name value_s)
	| #(TIC name attribute_id)
	;

definable_operator_symbol : OPERATOR_SYMBOL
	;

parenthesized_primary
	: #(PARENTHESIZED_PRIMARY ( NuLL | value_s extension_opt ) )
	;

extension_opt :  #(EXTENSION_OPT ( NuLL | value_s )? )
	;

def_designator
	: compound_name
	| definable_operator_symbol
	;

function_tail : formal_part_opt subtype_mark
	;

spec_decl_part
	: #(GENERIC_PACKAGE_INSTANTIATION def_id generic_inst)
	| #(PACKAGE_SPECIFICATION def_id pkg_spec_part)
	| #(PACKAGE_RENAMING_DECLARATION def_id renames)
	;

pkg_spec_part
	: basic_declarative_items_opt
	  private_declarative_items_opt
	  end_id_opt
	;

basic_declarative_items_opt
	: #(BASIC_DECLARATIVE_ITEMS_OPT ( basic_decl_item )* )
	;

private_declarative_items_opt
	: #(PRIVATE_DECLARATIVE_ITEMS_OPT ( basic_decl_item )* )
	;

basic_decl_item
	: spec_decl_part
	| task_type_or_single_decl
	| prot_type_or_single_decl
	| subprog_decl
	| decl_common
	;

task_type_or_single_decl
	: #(TASK_TYPE_DECLARATION def_id discrim_part_opt task_definition_opt)
	| #(SINGLE_TASK_DECLARATION def_id task_definition_opt)
	;

task_definition_opt
	: task_items_opt private_task_items_opt
	;

discrim_part_opt
	: #(DISCRIM_PART_OPT ( BOX | discriminant_specifications )? )
	;

discriminant_specifications
	: #(DISCRIMINANT_SPECIFICATIONS ( discriminant_specification )* )
	;

discriminant_specification
	: #(DISCRIMINANT_SPECIFICATION defining_identifier_list
		modifiers subtype_mark init_opt)
	;

init_opt : #(INIT_OPT ( expression )? )
	;  // `expression' is of course much too loose;
	   // semantic checks are required in the usage contexts.

task_items_opt
	: #(TASK_ITEMS_OPT entrydecls_repspecs_opt)
	;

entrydecls_repspecs_opt
	: ( entry_declaration | pragma | rep_spec )*
	;

entry_declaration
	: #(ENTRY_DECLARATION IDENTIFIER
		discrete_subtype_def_opt formal_part_opt)
	;

discrete_subtype_def_opt
	: #(DISCRETE_SUBTYPE_DEF_OPT ( discrete_subtype_definition )? )
	;

discrete_subtype_definition  // TBD
	: range
	| subtype_ind
	;

rep_spec : #(RECORD_REPRESENTATION_CLAUSE subtype_mark align_opt comp_loc_s)
	| #(AT_CLAUSE subtype_mark expression)
	| #(ATTRIBUTE_DEFINITION_CLAUSE subtype_mark expression)
	        // attrib_def. Semantic check must ensure that the
		// subtype_mark contains an attribute reference.
	| #(ENUMERATION_REPESENTATION_CLAUSE local_enum_name enumeration_aggregate)
	;

align_opt : #(MOD_CLAUSE_OPT ( expression )? )
	;

comp_loc_s
	: #(COMPONENT_CLAUSES_OPT
		( pragma
		| subtype_mark expression range
		)*
	   )
	;

private_task_items_opt
	: #(PRIVATE_TASK_ITEMS_OPT entrydecls_repspecs_opt )
	;

prot_type_or_single_decl
	: #(PROTECTED_TYPE_DECLARATION def_id discrim_part_opt protected_definition)
	| #(SINGLE_PROTECTED_DECLARATION def_id protected_definition)
	;

prot_private_opt : #(PROT_PRIVATE_OPT ( prot_member_decl_s )? )
        ;

protected_definition
	: prot_op_decl_s prot_private_opt end_id_opt
	;

prot_op_decl_s
	: #(PROT_OP_DECLARATIONS ( prot_op_decl )* )
	;

prot_op_decl
	: entry_declaration
	| #(PROCEDURE_DECLARATION def_id formal_part_opt)
	| #(FUNCTION_DECLARATION def_designator function_tail)
	| rep_spec
	| pragma
	;

prot_member_decl_s
	: #(PROT_MEMBER_DECLARATIONS ( prot_op_decl | comp_decl )* )
	;

comp_decl
	: #(COMPONENT_DECLARATION defining_identifier_list component_subtype_def init_opt)
	;

// decl_common is shared between declarative_item and basic_decl_item.
// decl_common only contains specifications.
decl_common
	: // type_def:
	  #(ENUMERATION_TYPE_DECLARATION IDENTIFIER enum_id_s)
	| #(SIGNED_INTEGER_TYPE_DECLARATION IDENTIFIER range)
	| #(MODULAR_TYPE_DECLARATION IDENTIFIER expression)
	| #(FLOATING_POINT_DECLARATION IDENTIFIER expression range_constraint_opt)
	| #(ORDINARY_FIXED_POINT_DECLARATION IDENTIFIER expression range)
	| #(DECIMAL_FIXED_POINT_DECLARATION IDENTIFIER expression expression range_constraint_opt)
	| array_type_declaration
	| access_type_declaration
	//
	| #(INCOMPLETE_TYPE_DECLARATION IDENTIFIER discrim_part_opt)
	// derived_or_private_or_record
	| #(PRIVATE_EXTENSION_DECLARATION id_and_discrim modifiers subtype_ind)
	| #(DERIVED_RECORD_EXTENSION id_and_discrim modifiers subtype_ind record_definition)
	| #(ORDINARY_DERIVED_TYPE_DECLARATION id_and_discrim subtype_ind)
	| #(PRIVATE_TYPE_DECLARATION id_and_discrim modifiers)
	| #(RECORD_TYPE_DECLARATION id_and_discrim modifiers record_definition)
	//
	| #(SUBTYPE_DECLARATION IDENTIFIER subtype_ind)
	| generic_decl
	| use_clause
	| rep_spec  // enumeration_representation_clause only
	| #(EXCEPTION_RENAMING_DECLARATION def_id compound_name)
	| #(OBJECT_RENAMING_DECLARATION def_id subtype_mark name)
	| #(EXCEPTION_DECLARATION defining_identifier_list)
	| #(NUMBER_DECLARATION defining_identifier_list expression)
	| #(ARRAY_OBJECT_DECLARATION defining_identifier_list modifiers
		array_type_definition init_opt)
	| #(OBJECT_DECLARATION defining_identifier_list modifiers
		subtype_ind init_opt)
	;

id_and_discrim
	: IDENTIFIER discrim_part_opt
	;

enum_id_s : ( enumeration_literal_specification )+
	;

enumeration_literal_specification : IDENTIFIER | CHARACTER_LITERAL
	;

array_type_definition
	: index_or_discrete_range_s component_subtype_def
	;

range_constraint_opt : ( range_constraint )?
	;

array_type_declaration
	: #(ARRAY_TYPE_DECLARATION IDENTIFIER array_type_definition)
	;

index_or_discrete_range_s
	: index_or_discrete_range
	| #(COMMA index_or_discrete_range_s index_or_discrete_range)
	;

index_or_discrete_range
	: #(DOT_DOT simple_expression simple_expression)
	| #(RANGE simple_expression ( BOX | range) )
	| simple_expression
	;

component_subtype_def : modifiers subtype_ind  // mod=aliased_opt
	;

subtype_ind
	: #(SUBTYPE_INDICATION subtype_mark constraint_opt)
	;

constraint_opt
	:	( range_constraint
		| digits_constraint
		| delta_constraint
		| index_constraint
		| discriminant_constraint
		)?
	;

digits_constraint
	: #(DIGITS_CONSTRAINT expression range_constraint_opt)
	;

delta_constraint
	: #(DELTA_CONSTRAINT expression range_constraint_opt)
	;

index_constraint
	: #(INDEX_CONSTRAINT ( discrete_range )+ )
	;

discrete_range
	: range
	| subtype_ind
	;

discriminant_constraint
	: #(DISCRIMINANT_CONSTRAINT ( discriminant_association )+ )
	;

discriminant_association
	: #(DISCRIMINANT_ASSOCIATION selector_names_opt expression)
	;

selector_names_opt
	: #(SELECTOR_NAMES_OPT ( selector_name )* )
	;

selector_name : IDENTIFIER  // TBD: sem pred
	;

access_type_declaration
	: #(ACCESS_TO_PROCEDURE_DECLARATION IDENTIFIER modifiers formal_part_opt)
	| #(ACCESS_TO_FUNCTION_DECLARATION IDENTIFIER modifiers function_tail)
	| #(ACCESS_TO_OBJECT_DECLARATION IDENTIFIER modifiers subtype_ind)
	;

record_definition : ( component_list )?
	;

component_list
	: component_items ( variant_part )?
	;

component_items
	: #(COMPONENT_ITEMS ( pragma | comp_decl )* )
	;

variant_part
	: #(VARIANT_PART discriminant_direct_name variant_s)
	;

discriminant_direct_name : IDENTIFIER  // TBD: symtab lookup.
	;

variant_s : #(VARIANTS ( variant )+ )
	;

variant : #(VARIANT choice_s ( component_list )? )
	;

choice_s : #(PIPE choice_s choice )
	| choice
	;

choice  : OTHERS
	| discrete_with_range
	| expression
	;

discrete_with_range : mark_with_constraint | range
	;

mark_with_constraint
	: #(MARK_WITH_CONSTRAINT subtype_mark range_constraint)
	;

local_enum_name : IDENTIFIER  // to be refined: do a symbol table lookup
	;

enumeration_aggregate : ( value )*
	;

generic_decl
	: #(GENERIC_PACKAGE_RENAMING generic_formal_part_opt def_id renames)
	| #(GENERIC_PACKAGE_DECLARATION generic_formal_part_opt def_id
		pkg_spec_part)
	| #(GENERIC_PROCEDURE_RENAMING generic_formal_part_opt def_id
		formal_part_opt renames)
	| #(GENERIC_PROCEDURE_DECLARATION generic_formal_part_opt def_id
		formal_part_opt)
	| #(GENERIC_FUNCTION_RENAMING generic_formal_part_opt def_designator
		function_tail renames)
	| #(GENERIC_FUNCTION_DECLARATION generic_formal_part_opt def_id
		function_tail)
	;

generic_formal_part_opt
	: #(GENERIC_FORMAL_PART
		( pragma | use_clause | generic_formal_parameter )*
	   )
	;

generic_formal_parameter
	: // FORMAL_TYPE_DECLARATIONs:
	  #(FORMAL_DISCRETE_TYPE_DECLARATION def_id)
	| #(FORMAL_SIGNED_INTEGER_TYPE_DECLARATION def_id)
	| #(FORMAL_MODULAR_TYPE_DECLARATION def_id)
	| #(FORMAL_DECIMAL_FIXED_POINT_DECLARATION def_id)
	| #(FORMAL_ORDINARY_FIXED_POINT_DECLARATION def_id)
	| #(FORMAL_FLOATING_POINT_DECLARATION def_id)
	| formal_array_type_declaration
	| formal_access_type_declaration
	| #(FORMAL_PRIVATE_TYPE_DECLARATION id_part modifiers)
	| #(FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION id_part subtype_ind)
	| #(FORMAL_PRIVATE_EXTENSION_DECLARATION id_part modifiers subtype_ind)
	| #(FORMAL_PROCEDURE_DECLARATION def_id formal_part_opt
		subprogram_default_opt)
	| #(FORMAL_FUNCTION_DECLARATION def_designator function_tail
		subprogram_default_opt)
	| #(FORMAL_PACKAGE_DECLARATION def_id compound_name formal_package_actual_part_opt)
	| parameter_specification
	;


id_part : def_id discrim_part_opt
	;

formal_array_type_declaration : array_type_declaration
	;

formal_access_type_declaration : access_type_declaration
	;

subprogram_default_opt : ( BOX | name )?
                      // #(SUBPROGRAM_DEFAULT_OPT ( BOX | name )? )
	;

formal_package_actual_part_opt
	: ( BOX | defining_identifier_list )?
	;

subprog_decl_or_rename_or_inst_or_body
	: subprog_decl
	| procedure_body
	| function_body
	;

procedure_body
	: #(PROCEDURE_BODY def_id formal_part_opt body_part)
	;

function_body
	: #(FUNCTION_BODY def_designator function_tail body_part)
	;

body_part : declarative_part block_body end_id_opt
	;

declarative_part
	: #(DECLARATIVE_PART ( pragma | declarative_item )* )
	;

// A declarative_item may appear in the declarative part of any body.
declarative_item
	: #(PACKAGE_BODY_STUB def_id)
	| #(PACKAGE_BODY def_id pkg_body_part)
	| spec_decl_part
	| #(TASK_BODY_STUB def_id)
	| #(TASK_BODY def_id body_part end_id_opt)
	| task_type_or_single_decl
	| #(PROTECTED_BODY_STUB def_id)
	| #(PROTECTED_BODY def_id prot_op_bodies_opt end_id_opt)
	| prot_type_or_single_decl
	| subprog_decl_or_rename_or_inst_or_body
	| decl_common
	;

pkg_body_part : declarative_part block_body_opt end_id_opt
	;

block_body_opt
	: #(BLOCK_BODY_OPT ( handled_stmt_s )? )
	;

prot_op_bodies_opt
	: #(PROT_OP_BODIES_OPT
		( pragma | entry_body | subprog_decl_or_body )*
	   )
	;

subprog_decl_or_body
	: procedure_body
	| #(PROCEDURE_DECLARATION def_id formal_part_opt)
	| function_body
	| #(FUNCTION_DECLARATION def_designator function_tail)
	;

block_body : #(BLOCK_BODY handled_stmt_s)
	;

handled_stmt_s
	: #(HANDLED_SEQUENCE_OF_STATEMENTS statements except_handler_part_opt)
	;

handled_stmts_opt
	: #(HANDLED_STMTS_OPT ( statements except_handler_part_opt )? )
	;

statements
	: #(SEQUENCE_OF_STATEMENTS ( pragma | statement )+ )
	;

statement : #(STATEMENT def_label_opt
		( null_stmt
		| exit_stmt
		| return_stmt
		| goto_stmt
		| delay_stmt
		| abort_stmt
		| raise_stmt
		| requeue_stmt
		| accept_stmt
		| select_stmt
		| if_stmt
		| case_stmt
		| loop_stmt id_opt
		| block end_id_opt
		| call_or_assignment
		// | code_stmt  // not yet implemented in parser
		)
	     )
	;

def_label_opt : #(LABEL_OPT ( IDENTIFIER )? )
	;

null_stmt : NULL_STATEMENT
	;

if_stmt : #(IF_STATEMENT cond_clause elsifs_opt else_opt)
	;

cond_clause : #(COND_CLAUSE condition statements)
	;

condition : expression
	;

elsifs_opt : #(ELSIFS_OPT ( cond_clause )* )
	;

else_opt : #(ELSE_OPT ( statements )? )
	;

case_stmt : #(CASE_STATEMENT expression alternative_s)
	;

alternative_s : ( case_statement_alternative )+
	;

case_statement_alternative
	: #(CASE_STATEMENT_ALTERNATIVE choice_s statements)
	;

loop_stmt
	: #(LOOP_STATEMENT iteration_scheme_opt statements)
        ;

iteration_scheme_opt
	: #(ITERATION_SCHEME_OPT
		( #(WHILE condition)
		| #(FOR IDENTIFIER modifiers discrete_subtype_definition)
		)?                // mod=reverse_opt
	   )
	;

block   : #(BLOCK_STATEMENT declare_opt block_body)
	;

declare_opt
	: #(DECLARE_OPT ( declarative_part )? )
	;

exit_stmt
	: #(EXIT_STATEMENT ( label_name )? ( WHEN condition )? ) // TBD !!!
	;

label_name : IDENTIFIER
	;

return_stmt
	: #(RETURN_STATEMENT ( expression )? )
	;

goto_stmt : #(GOTO_STATEMENT label_name)
	;

call_or_assignment
	: #(ASSIGNMENT_STATEMENT name expression)
	| #(CALL_STATEMENT name)
	;

entry_body
	: #(ENTRY_BODY def_id entry_body_formal_part entry_barrier body_part)
	;

entry_body_formal_part : entry_index_spec_opt formal_part_opt
	;

entry_index_spec_opt
	: #(ENTRY_INDEX_SPECIFICATION ( def_id discrete_subtype_definition )? )
	;

entry_barrier : condition
	;

entry_call_stmt
	: #(ENTRY_CALL_STATEMENT name)
	;

accept_stmt
	: #(ACCEPT_STATEMENT def_id entry_index_opt formal_part_opt
		handled_stmts_opt end_id_opt )
	;

entry_index_opt
	: #(ENTRY_INDEX_OPT ( expression )? )
	;

delay_stmt
	: #(DELAY_STATEMENT modifiers expression)  //mod=until_opt
	;

// SELECT_STATEMENT itself is not modeled since it is trivially
// reconstructed:
//   select_statement ::= selective_accept | timed_entry_call
//             | conditional_entry_call | asynchronous_select
//
select_stmt
	: #(ASYNCHRONOUS_SELECT triggering_alternative abortable_part)
	| #(SELECTIVE_ACCEPT selective_accept)
	| #(TIMED_ENTRY_CALL entry_call_alternative delay_alternative)
	| #(CONDITIONAL_ENTRY_CALL entry_call_alternative statements)
	;

triggering_alternative
	: #(TRIGGERING_ALTERNATIVE
		( delay_stmt | entry_call_stmt ) stmts_opt
	   )
	;

abortable_part
	: #(ABORTABLE_PART stmts_opt)
	;

entry_call_alternative
	: #(ENTRY_CALL_ALTERNATIVE entry_call_stmt stmts_opt)
	;

selective_accept : guard_opt select_alternative or_select_opt else_opt
	;

guard_opt : #(GUARD_OPT ( condition ( pragma )* )? )
	;

select_alternative
	: accept_alternative
        | delay_alternative
	| TERMINATE_ALTERNATIVE
	;

accept_alternative
	: #(ACCEPT_ALTERNATIVE accept_stmt stmts_opt)
	;

delay_alternative
	: #(DELAY_ALTERNATIVE delay_stmt stmts_opt)
	;

stmts_opt : ( pragma | statement )*
	;

or_select_opt
	: #(OR_SELECT_OPT ( guard_opt select_alternative )* )
	;

abort_stmt
	: #(ABORT_STATEMENT ( name )+ )
	;

except_handler_part_opt
	: #(EXCEPT_HANDLER_PART_OPT ( exception_handler )* )
	;

exception_handler
	: #(EXCEPTION_HANDLER identifier_colon_opt except_choice_s
		statements
	   )
	;

identifier_colon_opt
	: #(IDENTIFIER_COLON_OPT ( IDENTIFIER )? )
	;

except_choice_s
	: #(PIPE except_choice_s exception_choice)
	| exception_choice
	;

exception_choice : compound_name
	| OTHERS
	;

raise_stmt
	: #(RAISE_STATEMENT ( compound_name )? )
	;

requeue_stmt
	: #(REQUEUE_STATEMENT name ( ABORT )? )
	;

operator_call : #(OPERATOR_SYMBOL value_s)
	;

value_s : #(VALUES ( value )+ )
	;

expression
	: #(AND expression relation)
	| #(AND_THEN expression relation)
	| #(OR expression relation)
	| #(OR_ELSE expression relation)
	| #(XOR expression relation)
	| relation
	;

relation
	: #(IN simple_expression range_or_mark)
	| #(NOT_IN simple_expression range_or_mark)
	| #(EQ simple_expression simple_expression)
	| #(NE simple_expression simple_expression)
	| #(LT_ simple_expression simple_expression)
	| #(LE simple_expression simple_expression)
	| #(GT simple_expression simple_expression)
	| #(GE simple_expression simple_expression)
	| simple_expression
	;

range_or_mark
	: range
	| subtype_mark
	;

simple_expression
	: #(PLUS simple_expression signed_term)
	| #(MINUS simple_expression signed_term)
	| #(CONCAT simple_expression signed_term)
	| signed_term
	;

signed_term
	: #(UNARY_PLUS term)
	| #(UNARY_MINUS term)
	| term
	;

term    : #(STAR term factor)
	| #(DIV term factor)
	| #(MOD term factor)
	| #(REM term factor)
	| factor
	;

factor  : #(NOT primary)
	| #(ABS primary)
	| #(EXPON primary primary)
	| primary
	;

primary :
	( name_or_qualified
	| parenthesized_primary
	| allocator
	| NuLL
	| NUMERIC_LIT
	| CHARACTER_LITERAL
	| CHAR_STRING
	| operator_call
	)
	;

// Temporary, to be turned into just `qualified'.
// We get away with it because `qualified' is always mentioned
// together with `name'.
// Only exception: `code_stmt', which is not yet implemented.
name_or_qualified
	: IDENTIFIER
	| #(DOT name_or_qualified
		( ALL
		| IDENTIFIER
		| CHARACTER_LITERAL
		| OPERATOR_SYMBOL
		)
	   )
	| #(INDEXED_COMPONENT name_or_qualified value_s)
	| #(TIC name_or_qualified
		( parenthesized_primary
		| attribute_id
		)
	   )
	;

allocator : #(ALLOCATOR name_or_qualified)
	;

subunit : #(SUBUNIT compound_name
		( subprogram_body
		| package_body
		| task_body
		| protected_body
		)
	   )
	;

subprogram_body
	: procedure_body
	| function_body
	;

package_body : #(PACKAGE_BODY def_id pkg_body_part)
	;

task_body : #(TASK_BODY def_id body_part)
	;
 
protected_body : #(PROTECTED_BODY def_id prot_op_bodies_opt)
	;

// TBD
// code_stmt : #(CODE_STATEMENT qualified)
//  	;