C.2 AADL Core Language Syntax Rules
(1) The following is a summary of the AADL syntax as specified in the different sections of the document.
AADL_specification ::=
( package_spec | property_set )+
package_spec ::=
package defining_package_name
( public package_declarations [ private package_declarations ]
| private package_declarations )
[ properties ( { basic_property_association }+ |
none_statement ) ]
end defining_package_name ;
package_declarations ::=
{ name_visibility_declaration }* { AADL_declaration }*
package_name ::=
{ package_identifier :: }* package_identifier
none_statement ::= none ;
AADL_declaration ::=
classifier_declaration
| annex_library
classifier_declaration ::=
component_classifier_declaration | feature_group_classifier_declaration
component_classifier_declaration ::=
component_type | component_type_extension |
component_implementation | component_implementation_extension
feature_group_classifier_declaration ::=
feature_group_type | feature_group_type_extension
name_visibility_declaration ::=
import_declaration |
alias_declaration
import_declaration ::=
with ( package_name | property_set_identifier )
{ , ( package_name | property_set_identifier ) }* ;
alias_declaration ::=
( defining_identifier renames package package_name ; ) |
( [ defining_identifier ] renames
( component_category unique_component_type_reference |
feature group unique_feature_group_type_reference ) ; ) |
( renames package_name::all ; )
NOTES:
The properties subclause of the package is optional, or requires an explicit empty subclause declaration. The latter is provided to accommodate AADL modeling guidelines that require explicit documentation of empty subclauses. An empty subclause declaration consists of the reserved word of the subclause and a none statement ( none ; ).
component_type ::=
component_category defining_component_type_identifier
[ prototypes ( { prototype }+ | none_statement ) ]
[ features ( { feature }+ | none_statement ) ]
[ flows ( { flow_spec }+ | none_statement ) ]
[ modes_subclause | requires_modes_subclause ]
[ properties (
{ component_type_property_association | contained_property_association }+
| none_statement ) ]
{ annex_subclause }*
end defining_component_type_identifier ;
component_type_extension ::=
component_category defining_component_type_identifier
extends unique_component_type_reference [ prototype_bindings ]
[ prototypes ( { prototype | prototype_refinement }+ | none_statement ) ]
[ features ( { feature | feature_refinement }+ | none_statement ) ]
[ flows ( { flow_spec | flow_spec_refinement }+ | none_statement ) ]
[ modes_subclause | requires_modes_subclause ]
[ properties (
{ component_type_property_association | contained_property_association }+
| none_statement ) ]
{ annex_subclause }*
end defining_component_type_identifier ;
component_category ::=
abstract_component_category
| software_category
| execution_platform_category
| composite_category
abstract_component_category ::= abstract
software_category ::= data | subprogram | subprogram group |
thread | thread group | process
execution_platform_category ::=
memory | processor | bus | device | virtual processor | virtual bus
composite_category ::= system
unique_component_type_reference ::=
[ package_name :: ] component_type_identifier
NOTES: The above grammar rules characterize the common syntax for all component categories. The sections defining each of the component categories will specify further restrictions on the syntax.
The prototypes, features, flows, modes, annex, and properties subclauses of the component type are optional, or require an explicit empty subclause declaration. The latter is provided to accommodate AADL modeling guidelines that require explicit documentation of empty subclauses. An empty subclause declaration consists of the reserved word of the subclause and a none statement ( none ; ).
component_implementation ::=
component_category implementation
defining_component_implementation_name [ prototype_bindings ]
[ prototypes ( { prototype }+ | none_statement ) ]
[ subcomponents ( { subcomponent }+ | none_statement ) ]
[ calls ( { subprogram_call_sequence }+ | none_statement ) ]
[ connections ( { connection }+ | none_statement ) ]
[ flows ( { flow_implementation |
end_to_end_flow_spec }+ | none_statement ) ]
[modes_subclause ]
[ properties ( { property_association | contained_property_association }+
| none_statement ) ]
{ annex_subclause }*
end defining_component_implementation_name ;
component_implementation_name ::=
component_type_identifier . component_implementation_identifier
component_implementation_extension ::=
component_category implementation
defining_component_implementation_name
extends unique_component_implementation_reference [ prototype_bindings ]
[ prototypes ( { prototype | prototype_refinement }+ | none_statement ) ]
[ subcomponents
( { subcomponent | subcomponent_refinement }+ | none_statement ) ]
[ calls ( { subprogram_call_sequence }+ | none_statement ) ]
[ connections
( { connection | connection_refinement }+ | none_statement ) ]
[ flows ( { flow_implementation | flow_implementation_refinement |
end_to_end_flow_spec | end_to_end_flow_spec_refinement }+
| none_statement ) ]
[modes_subclause ]
[ properties ( { property_association | contained_property_association }+
| none_statement ) ]
{ annex_subclause }*
end defining_component_implementation_name ;
unique_component_implementation_reference ::=
[ package_name :: ] component_implementation_name
NOTES: The above grammar rules characterize the common syntax for all component categories. The sections defining each of the component categories will specify further restrictions on the syntax.
The prototypes, subcomponents, connections, calls, flows, modes, and properties subclauses of the component implementation are optional or if used and empty, require an explicit empty declaration. The latter is provided to accommodate AADL modeling guidelines that require explicit documentation of empty subclauses. An empty subclause declaration consists of the reserved word of the subclause and a none statement ( none ; ).
The annex_subclause of the component implementation is optional.
The refines type subclause of AADL V1 has been removed. Its role was to allow association of implementation-specific property values to features and flow specifications declared in the component type. The same can be achieved by contained property associations whose applies to subclause names the feature or flow specification.
subcomponent ::=
defining_subcomponent_identifier :
component_category
[ unique_component_classifier_reference [prototype_bindings]
| prototype_identifier ]
[ array_dimensions [ array_element_implementation_list ] ]
[ { { subcomponent_property_association
| contained_property_association }+ } ]
[ component_in_modes ] ;
subcomponent_refinement ::=
defining_subcomponent_identifier : refined to
component_category
[ unique_component_classifier_reference [ prototype_bindings ]
| prototype_identifier ]
[ array_dimensions [ array_element_implementation_list ] ]
[ { { subcomponent_property_association
| contained_property_association }+ } ]
[ component_in_modes ] ;
unique_component_classifier_reference ::=
( unique_component_type_reference
| unique_component_implementation_reference )
array_dimensions ::=
{ array_dimension }+
array_dimension ::=
[ [ array_dimension_size ] ]
array_dimension_size ::=
numeral | unique_property_constant_identifier | unique_property_identifier
array_element_implementation_list ::=
( unique_component_implementation_reference [ prototype_bindings ]
{ , unique_component_implementation_reference [ prototype_bindings ] }* )
-- array selection used in contained property association and references
array_selection_identifier ::=
identifier array_selection
array_selection ::=
{ [ selection_range ] }+
selection_range ::=
numeral [ .. numeral ]
NOTES:
The above grammar rules characterize the common syntax for subcomponent of all component categories. The sections defining each of the component categories will specify further restrictions on the syntax.
prototype ::=
defining_prototype_identifier :
( component_prototype
| feature_group_type_prototype
| feature_prototype )
[ { { prototype_property_association }+ } ] ;
component_prototype ::=
component_category [ unique_component_classifier_reference ] [ [] ]
feature_group_type_prototype ::=
feature group [ unique_feature_group_type_reference ]
feature_prototype ::=
[ in | out ] feature [unique_component_classifier_reference ]
prototype_refinement ::=
defining_prototype_identifier : refined to
( component_prototype
| feature_group_type_prototype
| feature_prototype )
[ { { prototype_property_association }+ } ];
prototype_bindings ::=
( prototype_binding { , prototype_ binding }* )
prototype_binding ::=
prototype_identifier =>
( component_prototype_actual | component_prototype_actual_list
| feature_group_type_prototype_actual | feature_prototype_actual )
component_prototype_actual ::=
component_category
( unique_component_classifier_reference [ prototype_bindings ]
| prototype_identifier )
component_prototype_actual_list ::=
( component_prototype_actual { , component_prototype_actual }* )
feature_group_type_prototype_actual ::=
( feature group unique_feature_group_type_reference [ prototype_bindings ] )
| (feature group feature_group_type_prototype_identifier )
feature_prototype_actual ::=
( (( in | out | in out) ( event | data | event data ) port ) |
( ( requires | provides )
( bus | data | subprogram group | subprogram ) access )
[ unique_component_classifier_reference ] )
| ( [ in | out ] feature feature_prototype_identifier )
annex_subclause ::=
annex annex_identifier (
( {** annex_specific_language_constructs **} ) | none )
[ in_modes ] ;
annex_library ::=
annex annex_identifier
(( {** annex_specific_reusable_constructs **} ) | none ) ;
subprogram_call_sequence ::=
defining_call_sequence_identifier :
{ { subprogram_call }+ }
[ { { call_sequence_property_association }+ } ] [ in_modes ] ;
subprogram_call ::=
defining_call_identifier : subprogram called_subprogram
[ { { subcomponent_call_property_association }+ } ] ;
called_subprogram ::=
-- identification by classifier
subprogram_unique_component_classifier_reference
| ( data_unique_component_type_reference
. data_provides_subprogram_access_identifier )
| ( subprogram_group_unique_component_type_reference
. provides_subprogram_access_identifier )
| ( abstract_unique_component_type_reference
. provides_subprogram_access_identifier )
| ( feature_group_identifier
. requires_subprogram_access_identifier )
-- identification by prototype
| component_prototype_identifier
-- identification by processor subprogram access feature
| ( processor . provides_subprogram_access_identifier )
-- identification by subprogram instance
| subprogram_subcomponent_identifier
| ( subprogram_group_subcomponent_identifier .
provides_subprogram_access_identifier )
| requires_subprogram_access_identifier
| ( requires_subprogram_group_access_identifier .
provides_subprogram_access_identifier )
NOTES:
Subprogram type and implementation declarations follow the syntax rules for component types and implementations. Subprogram instances may be implied by subprogram calls referring to subprogram classifiers, or subprogram instances may be declared explicitly as subprogram subcomponents and made accessible to calls through provides and requires subprogram access declarations.
feature ::=
( abstract_feature_spec |
port_spec |
feature_group_spec |
subcomponent_access_spec |
parameter_spec )
[ array_dimension ]
[ { { feature_contained_property_association }+ } ] ;
subcomponent_access_spec ::=
subprogram_access_spec | subprogram_group_access_spec
| data_access_spec | bus_access_spec
feature_refinement ::=
abstract_feature_refinement
port_refinement |
feature_group_refinement |
subcomponent_access_refinement |
parameter_refinement
[ array_dimension ]
[ { { feature_contained_property_association }+ } ] ;
subcomponent_access_refinement ::=
subprogram_access_refinement | subprogram_group_access_refinement
| data_access_refinement | bus_access_refinement
abstract_feature_spec ::=
defining_abstract_feature_identifier :
[ in | out ] feature [ feature_prototype_identifier ]
abstract_feature_spec ::=
defining_abstract_feature_identifier :
[ in | out ] feature [ feature_prototype_identifier ]
abstract_feature_refinement ::=
( defining_abstract_feature_identifier : refined to
[ in | out ] feature [ feature_prototype_identifier ] )
| port_refinement | feature_group_refinement
| subcomponent_access_refinement | parameter_refinement
-- Defining the content structure of a feature group
feature_group_type ::=
feature group defining_identifier
[ prototypes ( { prototype }+ | none_statement ) ]
[ features { feature }+ ]
[ inverse of unique_feature_group_type_reference ]
[ properties ( { feature_group_contained_property_association }+ | none_statement ) ]
{ annex_subclause }*
end defining_identifier ;
feature_group_type_extension ::=
feature group defining_identifier
extends unique_feature_group_type_reference [ prototype_bindings ]
[ prototypes ( { prototype | prototype_refinement }+ | none_statement ) ]
[ features { feature | feature_refinement }+ ]
[ inverse of unique_feature_group_type_reference ]
[ properties ( { feature_group_contained_property_association }+ | none_statement ) ]
{ annex_subclause }*
end defining_identifier ;
-- declaring a feature group as component feature
feature_group_spec ::=
defining_feature_group_identifier : [ in | out ] feature group
[ [ inverse of ]
( unique_feature_group_type_reference | feature_group_prototype_identifier ) ]
feature_group_refinement ::=
defining_feature_group_identifier : refined to [ in | out ] feature group
[ [ inverse of ]
( unique_feature_group_type_reference | feature_group_prototype_identifier ) ]
unique_feature_group_type_reference ::=
[ package_name :: ] feature_group_type_identifier
port_spec ::=
defining_port_identifier : ( in | out | in out ) port_type
port_refinement ::=
defining_port_identifier : refined to
( in | out | in out ) port_type
port_type ::=
data port [ data_unique_component_classifier_reference
| data_component_prototype_identifier ]
| event data port [ data_unique_component_classifier_reference
| data_component_prototype_identifier ]
| event port
-- The requires and provides subprogram access subclause
subprogram_access_spec ::=
defining_subprogram_access_identifier :
( provides | requires ) subprogram access
[ subprogram_unique_component_classifier_reference
| subprogram_component_prototype_identifier ]
subprogram_access_refinement ::=
defining_subprogram_access_identifier : refined to
( provides | requires ) subprogram access
[ subprogram_unique_component_classifier_reference
| subprogram_component_prototype_identifier ]
-- The requires and provides subprogram group access subclause
subprogram_group_access_spec ::=
defining_subprogram_group_access_identifier :
( provides | requires ) subprogram group access
[ subprogram_group_unique_component_classifier_reference
| subprogram_group_component_prototype_identifier ]
subprogram_group_access_refinement ::=
defining_subprogram_group_access_identifier : refined to
( provides | requires ) subprogram group access
[ subprogram_group_unique_component_classifier_reference
| subprogram_group_component_prototype_identifier ]
parameter_spec ::=
defining_parameter_identifier :
( in | out | in out ) parameter
[ data_unique_component_classifier_reference |
data_component_prototype_identifier ]
parameter_refinement ::=
defining_parameter_identifier : refined to
( in | out | in out ) parameter
[ data_unique_component_classifier_reference |
data_component_prototype_identifier ]
-- The requires and provides subcomponent access subclause
data_access_spec ::=
defining_data_component_access_identifier :
( provides | requires ) data access
[ data_unique_component_classifier_reference
| prototype_identifier ]
data_access_refinement ::=
defining_data_component_access_identifier : refined to
( provides | requires ) data access
[ data_unique_component_classifier_reference
| prototype_identifier ]
-- The requires and provides bus access subclause
bus_access_spec ::=
defining_bus_access_identifier :
( provides | requires ) bus access
[ bus_unique_component_classifier_reference
| prototype_identifier ]
bus_access_refinement ::=
defining_bus_access_identifier : refined to
( provides | requires ) bus access
[ bus_unique_component_classifier_reference
| prototype_identifier ]
connection ::=
defining_connection_identifier :
( feature_connection
| port_connection
| parameter_connection
| access_connection
| feature_group_connection )
[ { { property_association }+ } ]
[ in_modes_and_transitions ] ;
connection_refinement ::=
defining_connection_identifier : refined to
( feature_connection_refinement
| port_connection_refinement
| parameter_connection_refinement
| access_connection_refinement
| feature_group_connection_refinement )
[ { { property_association }+ } ]
[ in_modes_and_transitions ] ;
feature_connection ::=
feature source_feature_reference connection_symbol
destination_feature_reference
connection_symbol ::=
directional_connection_symbol | bidirectional_connection_symbol
directional_connection_symbol ::= ->
bidirectional_connection_symbol ::= <->
feature_reference ::=
-- feature in the component type
component_type_feature_identifier |
-- feature in a feature group of the component type
component_type_feature_group_identifier . feature_identifier |
-- feature in a subcomponent
subcomponent_identifier . feature_identifier
-- feature in a call
subprogram_call_identifier . feature_identifier
feature_connection_refinement ::=
feature
port_connection ::=
port
source_port_connection_reference
connection_symbol
destination_port_connection_reference
port_connection_refinement ::=
port
port_connection_reference ::=
-- port in the component type
component_type_port_identifier
|
-- port in a subcomponent
subcomponent_identifier . port_identifier
|
-- port element in a feature group of the component type
component_type_feature_group_identifier . element_port_identifier
|
-- data element in aggregate data port
component_type_port_identifier . data_subcomponent_identifier
|
-- requires data access in the component type
component_type_requires_data_access_identifier
|
-- data subcomponent
data_subcomponent_identifier
|
-- data component provided by a subcomponent
subcomponent_identifier . provides_data_access_identifier
|
-- data access element in a feature group of the component type
component_type_feature_group_identifier . element_data_access_identifier
|
-- access to element in a data subcomponent
data_subcomponent_identifier .data_subcomponent_identifier
|
-- processor port
processor . processor_port_identifier
|
-- component itself as event or event data source
self . event_or_event_data_source_identifier
-- Note: data port, event data port, and event port connections
-- are replaced by port connections in AADL V2
parameter_connection ::=
parameter source_parameter_reference
directional_connection_symbol destination_parameter_reference
parameter_connection_refinement ::=
parameter
parameter_reference ::=
-- parameter in the thread or subprogram type
component_type_parameter_identifier [ . data_subcomponent_identifier ]
|
-- parameter in another subprogram call
subprogram_call_identifier . parameter_identifier
|
-- data or event data port in the thread type
-- or an element of that port’s data
component_type_port_identifier [ . data_subcomponent_identifier ]
|
-- data subcomponent in the thread or subprogram
data_subcomponent_identifier
|
-- requires data access in the thread or subprogram type
requires_data_access_identifier
|
-- data access element in a feature group of the component type
component_type_feature_group_identifier . element_data_access_identifier
|
-- port or parameter element in a feature group of the component type
component_type_feature_group_identifier . element_port_or_parameter_identifier
access_connection ::=
[ bus | subprogram | subprogram group | data ] access
source_access_reference connection_symbol destination_access_reference
access_connection_refinement ::=
[ bus | subprogram | subprogram group | data ] access
access_reference ::=
-- requires or provides access feature in the component type
requires_access_identifier | provides_access_identifier
|
-- requires or provides access feature in a feature group of the component type
feature_group_identifier . requires_access_identifier
|
feature_group_identifier . provides_access_identifier
|
-- provides or requires access in a subcomponent
subcomponent_identifier . provides_access_identifier
|
subcomponent_identifier . requires_access_identifier
|
subprogram_call_identifier . requires_or_provides_access_identifier
-- data, subprogram, subprogram group or bus being accessed
data_subprogram_subprogram_group_or_bus_subcomponent_identifier
|
-- subprogram a processor being accessed
processor . provides_subprogram_access_identifier
-- connection between feature groups of two subcomponents or between
-- a feature group of a subcomponent and a feature group in the component type
feature_group_connection ::=
feature group source_feature_group_reference
connection_symbol destination_feature_group_reference
-- A feature group refinement can only add properties
-- The source and destination of the connection does not have to be repeated
feature_group_connection_refinement ::=
feature group
feature_group_reference ::=
-- feature group in the component type
component_type_feature_group_identifier
|
-- feature group in a subcomponent
subcomponent_identifier . feature_group_identifier
|
-- feature group element in a feature group of the component type
component_type_feature_group_identifier .
element_feature_group_identifier
flow_spec ::=
flow_source_spec
| flow_sink_spec
| flow_path_spec
flow_spec_refinement ::=
flow_source_spec_refinement
| flow_sink_spec_refinement
| flow_path_spec_refinement
flow_source_spec ::=
defining_flow_identifier : flow source out_flow_feature_identifier
[ { { property_association }+ } ]
[ in_modes ] ;
flow_sink_spec ::=
defining_flow_identifier : flow sink in_flow_feature_identifier
[ { { property_association }+ } ]
[ in_modes ] ;
flow_path_spec ::=
defining_flow_identifier : flow path in_flow_feature_identifier ->
out_flow_feature_identifier
[ { { property_association }+ } ]
[ in_modes ] ;
flow_source_spec_refinement ::=
defining_flow_identifier :
refined to flow source
( ( { { property_association }+ } [ in_modes_and_transitions ] ) |
in_modes_and_transitions ) ;
flow_sink_spec_refinement ::=
defining_flow_identifier :
refined to flow sink
( ( { { property_association }+ } [ in_modes_and_Transitions ] ) |
in_modes_and_transitions ) ;
flow_path_spec_refinement ::=
defining_flow_identifier :
refined to flow path
( ( { { property_association }+ } [ in_modes_and_transitions ] ) |
in_modes_and_transitions ) ;
flow_feature_identifier ::=
feature_identifier
| feature_group_identifier
| feature_group_identifier . feature_identifier
| feature_group_identifier . feature_group_identifier
flow_implementation ::=
( flow_source_implementation
| flow_sink_implementation
| flow_path_implementation )
[ { { property_association }+ } ]
[ in_modes_and_transitions ] ;
flow_source_implementation ::=
flow_identifier : flow source
{ subcomponent_flow_identifier -> connection_identifier -> }*
out_flow_feature_identifier
flow_sink_implementation ::=
flow_identifier : flow sink
in_flow_feature_identifier
{ -> connection_identifier -> subcomponent_flow_identifier }*
flow_path_implementation ::=
flow_identifier : flow path
in_flow_feature_identifier
[ { -> connection_identifier -> subcomponent_flow_identifier }+
-> connection_identifier ]
-> out_flow_feature_identifier
subcomponent_flow_identifier ::=
( subcomponent_identifier [ . flow_spec_identifier ] )
| data_component_reference
data_component_reference ::=
data_subcomponent_identifier | requires_data_access_identifier
| provides_data_access_identifier
end_to_end_flow_spec ::=
defining_end_to_end_flow_identifier : end to end flow
start_subcomponent_flow_or_etef_identifier
{ -> connection_identifier
-> flow_path_subcomponent_flow_or_etef_identifier }+
[ { ( property_association }+ } ]
[ in_modes_and_transitions ] ;
end_to_end_flow_spec_refinement ::=
defining_end_to_end_identifier :
refined to end to end flow
( { { property_association }+ } [ in_modes_and_transitions ]
| in_modes_and_transitions
) ;
subcomponent_flow_or_etef_identifier ::=
subcomponent_flow_identifier | end_to_end_flow_identifier
property_set ::=
property set defining_property_set_identifier is
{ import_declaration }*
{ property_type_declaration
| property_definition_declaration
| property_constant }*
end defining_property_set_identifier ;
property_type_declaration ::=
defining_property_type_identifier : type property_type ;
property_type ::=
aadlboolean | aadlstring
| enumeration_type | units_type
| number_type | range_type
| classifier_type
| reference_type
| record_type
enumeration_type ::=
enumeration ( defining_enumeration_literal_identifier
{ , defining_enumeration_literal_identifier }*)
units_type ::=
units units_list
units_list ::=
( defining_unit_identifier
{ , defining_unit_identifier => unit_identifier * numeric_literal }* )
number_type ::=
aadlreal [ real_range ] [ units units_designator ]
| aadlinteger [ integer_range ] [ units units_designator ]
units_designator ::=
units_unique_property_type_identifier
| units_list
real_range ::= real_lower_bound .. real_upper_bound
real_lower_bound ::= signed_aadlreal_or_constant
real_upper_bound ::= signed_aadlreal_or_constant
integer_range ::= integer_lower_bound .. integer_upper_bound
integer_lower_bound ::= signed_aadlinteger_or_constant
integer_upper_bound ::= signed_aadlinteger_or_constant
signed_aadlreal_or_constant ::=
( signed_aadlreal | [ sign ] real_property_constant_term )
signed_aadlinteger_or_constant ::=
( signed_aadlinteger | [ sign ] integer_property_constant_term )
sign ::= + | -
signed_aadlinteger ::=
[ sign ] integer_literal [ unit_identifier ]
signed_aadlreal ::=
[ sign ] real_literal [ unit_identifier ]
range_type ::=
range of number_type
| range of number_unique_property_type_identifier
classifier_type ::=
classifier
[ ( classifier_category_reference { , classifier_category_reference }* ) ]
classifier_category_reference ::=
-- AADL or Annex meta model classifier
classifier_qualified_meta_model_identifier
qualified_meta_model_identifier ::=
[ { annex_identifier }** ] meta_model_class_identifier
meta_model_class_identifier ::= { identifier }+
reference_type ::=
reference [ ( reference_category
{ , reference_category }* ) ]
reference_category ::=
-- AADL or Annex meta model named element
named_element_qualified_meta_model_identifier
unique_property_type_identifier ::=
[ property_set_identifier :: ] property_type_identifier
record_type ::=
record ( record_field
{ record_field }* )
record_field ::=
defining_field_identifier : [ list of ] property_type_designator ;
property_type_designator ::=
unique_property_type_identifier |
property_type
property_definition_declaration ::=
defining_property_name_identifier:
[ inherit ]
( single_valued_property | multi_valued_property )
applies to ( property_owner { , property_owner }* ) ;
single_valued_property ::=
property_type_designator [ => default_property_expression ]
multi_valued_property ::=
{ list of }+ property_type_designator
[ => default_property_list_value
]
property_owner ::=
-- AADL or Annex meta model named element
named_element_qualified_meta_model_identifier |
unique_classifier_reference
unique_classifier_reference ::=
package_name :: classifier_identifier
Note: Different from AADL V1 the access keyword is no longer used in property definitions. The fact that a property applies to an access feature is already specified in the applies to clause.
property_constant ::=
single_valued_property_constant | multi_valued_property_constant
single_valued_property_constant ::=
defining_property_constant_identifier : constant
property_type_designator
=> constant_property_expression;
multi_valued_property_constant ::=
defining_property_constant_identifier : constant ( list of )+
property_type_designator
=> constant_property_list_value ;
unique_property_constant_identifier ::=
[ property_set_identifier :: ] property_constant_identifier
basic_property_association ::=
unique_property_identifier
( => | +=> )
[ constant ] property_value ;
property_association ::=
unique_property_identifier
( => | +=> )
[ constant ] assignment
[ in_binding ] ;
contained_property_association ::=
unique_property_identifier
=> [ constant ] assignment
applies to contained_model_element_path
{ , contained_model_element_path }*
[ in_binding ] ;
unique_property_identifier ::=
[ property_set_identifier :: ] property_name_identifier
contained_model_element_path ::=
( contained_model_element { . contained_model_element }*
[ annex_path ] )
| annex_path
contained_model_element ::=
named_element_identifier |
named_element_array_selection_identifier
annex_path ::=
annex annex_identifier {** annex_specific_path **}
annex_specific_path ::= <defined by annex>
-- It is recommended this path follows the dot-separation syntax of the component path.
assignment ::= property_value | modal_property_value
modal_property_value ::=
{ property_value in_modes , }* property_value [ in_modes ]
property_value ::= single_property_value | property_list_value
single_property_value ::= property_expression
property_list_value ::=
( [ ( property_list_value | property_expression )
{ , ( property_list_value | property_expression ) }* ] )
in_binding ::=
in binding( platform_classifier_reference
{ , platform_classifier_reference }* )
platform_classifier_reference ::=
processor_unique_component_classifier_reference
| virtual_processor_unique_component_classifier_reference
| bus_unique_component_classifier_reference
| virtual_bus_unique_component_classifier_reference
| memory_unique_component_classifier_reference
property_expression ::=
boolean_term
| real_term
| integer_term
| string_term
| enumeration_term
| unit_term
| real_range_term
| integer_range_term
| property_term
| component_classifier_term
| reference_term
| record_term
| computed_term
boolean_term ::=
boolean_value
| boolean_property_constant_term
boolean_value ::= true | false
real_term ::=
signed_aadlreal_or_constant
integer_term ::=
signed_aadlinteger_or_constant
string_term ::= string_literal | string_property_constant_term
enumeration_term ::=
enumeration_identifier | enumeration_property_constant_term
unit_term ::=
unit_identifier | unit_property_constant_term
integer_range_term ::=
integer_term .. integer_term [ delta integer_term ]
| integer_range_property_constant_term
real_range_term ::=
real_term .. real_term [ delta real_term ]
| real_range_property_constant_term
property_term ::=
[ property_set_identifier :: ] property_name_identifier
property_constant_term ::=
[ property_set_identifier :: ] property_constant_identifier
component_classifier_term ::=
classifier (
( unique_component_type_reference |
unique_component_implementation_reference ) )
reference_term ::=
reference ( contained_model_element_path )
record_term ::=
[ record_field_identifier => property_value ;
{ record_field_identifier => property_value; }* ]
computed_term ::=
compute ( function_identifier )
modes_subclause ::=
modes ( { mode | mode_transition }+ | none_statement )
requires_modes_subclause ::=
requires modes ( { mode }+ | none_statement )
mode ::=
defining_mode_identifier : [ initial ] mode
[ { { mode_property_association }+ } ];
mode_transition ::=
[ defining__mode_transition_identifier : ]
source_mode_identifier
-[ mode_transition_trigger { , mode_transition_trigger }* ]->
destination_mode_identifier
[ { { mode_transition_property_association }+ } ] ;
mode_transition_trigger ::=
unique_port_identifier | self . event_or_event_data_source_identifier
| processor . port_identifier
unique_port_identifier ::=
[ subcomponent_or_feature_group_or_subprogram_call_identifier . ] port_identifier
in_modes ::=
in modes ( mode_identifier { , mode_identifier }* )
component_in_modes ::=
in modes ( ( mode_name { , mode_name }* ) )
mode_name ::= local_mode_identifier [ => subcomponent_mode_identifier ]
in_modes_and_transitions ::=
in modes ( ( mode_or_transition { , mode_or_transition }* )
mode_or_transition ::=
mode_identifier | mode_transition_identifier