![]() ![]() |
|||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||
Informative
The
AADL has the following restrictions on the constructs that are permitted in the component
type and component implementation of each component category.
The
following is a summary of the AADL syntax as specified in the different sections of the
document.
AADL_specification
::=
{ AADL_global_declaration | AADL_declaration }+
AADL_global_declaration
::= package_spec | property_set
AADL_declaration
::=
component_classifier
| port_group_classifier
| annex_library
component_classifier
::=
component_type | component_type_extension |
component_implementation | component_implementation_extension
port_group_classifier
::=
port_group_type
| port_group_type_extension
package_spec
::=
package defining_package_name
( publicpackage_declaration [ private package_declaration ]
| private package_declaration )
end defining_package_name
;
package_declaration
::= { aadl_declaration }+
[ properties ( { property_association }+ |
none_statement
) ]
package_name
::=
{ package_identifier :: }* package_identifier
none_statement
::= none ;
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
[ features ( { feature }+ | none_statement ) ]
[ flows ( { flow_spec }+ | none_statement ) ]
[ properties ( { component_type_property_association }+ |
none_statement ) ]
{ annex_subclause }*
enddefining_component_type_identifier ;
component_type_extension
::=
component_category defining_component_type_identifier
extends
unique_component_type_identifier
[ features ( { feature | feature_refinement }+ | none_statement ) ]
[ flows ( { flow_spec | flow_spec_refinement }+ | none_statement ) ]
[ properties ( { component_type_property_association }+ |
none_statement ) ]
{ annex_subclause }*
enddefining_component_type_identifier ;
component_category
::=
software_category
| execution_platform_category
| composite_category
software_category
::= data | subprogram | thread | thread group |
process
execution_platform_category
::= memory | processor | bus | device
composite_category
::= system
unique_component_type_identifier::=
[ 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 features, flows, 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 ;).
The annex_subclause of the component type is optional.
component_implementation
::=
component_category implementation
defining_component_implementation_name
[ refines type ( { feature_refinement }+ | 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 ( { mode }+ { mode_transition }* | none_statement ) ]
[ 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
extendsunique_component_implementation_name
[ refines type
( { feature_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 ( { mode | mode_refinement | mode_transition }+ |
none_statement ) ]
[ properties ( { property_association }+ | none_statement ) ]
{ annex_subclause }*
end defining_component_implementation_name ;
unique_component_implementation_name ::=
[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 refines type, 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.
subcomponent
::=
defining_subcomponent_identifier
:
component_category [ component_classifier_reference ]
[ { { subcomponent_property_association
| contained_property_association }+ } ]
[
in_modes ] ;
subcomponent_refinement
::=
defining_subcomponent_identifier
: refined to
component_category [ component_classifier_reference ]
[ { { subcomponent_property_association
| contained_property_association }+ } ]
[
in_modes ] ;
component_classifier_reference
::=
unique_component_type_name [ .
component_implementation_name ]
NOTES:
Theabove 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.
annex_subclause
::=
annex annex_identifier {**
annex_specific_language_constructs
**}
;
annex_library
::=
annex annex_identifier {**
annex_specific_reusable_constructs
**}
;
subprogram_call_sequence
::=
[ defining_call_sequence_identifier :]
{
{ subprogram_call }+ } [ in_modes ] ;
subprogram_call
::=
defining_call_identifier : subprogramcalled_subprogram
[ { { subcomponent_call_property_association }+ } ] ;
called_subprogram
::=
subprogram_classifier_reference
| data_unique_type_reference . data_subprogram_identifier
NOTES:
Subprogram
type and implementation declarations follow the syntax rules for component types
and implementations. Subprograms are not instantiated as subcomponents. Instead subprogram
calls represent their instantiation (use) with a specific set of parameter values. The syntax
for
specifying call sequences is shown here.
mode
::=
defining_mode_identifier
: [ initial ] mode
[ {
{ mode_property_assocation }+ }];
mode_transition
::=
source_mode_identifier
{ ,source_mode_identifier }*
-[
unique_port_identifier { , unique_port_identifier }* ]->
destination_mode_identifier ;
mode_refinement ::=
defining_mode_identifier
: refined tomode
{
{ mode_property_assocation }+ } ;
in_modes
::=
in
modes ( ( mode_identifier { ,mode_identifier }*
| none ) )
in_modes_and_transitions
::=
in
modes ( ( mode_or_transition { ,mode_or_transition }*
| none ) )
mode_or_transition
::=
mode_identifier
| (old_mode_identifier -> new_mode_identifier )
feature
::=
port_spec |
port_group_spec |
server_subprogram_spec |
data_subprogram_spec |
subcomponent_access |
parameter
feature_refinement
::=
port_refinement |
port_group_refinement |
server_subprogram_refinement |
data_subprogram_refinement |
subcomponent_access_refinement |
parameter_refinement
port_spec
::=
defining_port_identifier
: ( in | out | in out ) port_type
[ { { port_property_association }+ }] ;
port_refinement
::=
defining_port_identifier
: refined to
( in | out | in out ) port_type
[ { { port_property_association }+ }] ;
port_type
::=
data port [ data_classifier_reference ]
| event data port [ data_classifier_reference ]
| event port
--
Defining the content structure of a port group
port_group_type
::=
port
group defining_identifier
( features
{ port_spec | port_group_spec }*
[ inverse ofunique_port_group_type_reference ]
|
inverse
ofunique_port_group_type_reference
)
[ properties(
{ portgroup_property_association }+ | none_statement ) ]
{
annex_subclause }*
enddefining_identifier ;
port_group_type_extension
::=
port
group defining_identifier
extendsunique_port_group_type_reference
( features
{ port_spec | port_refinement |
port_group_spec | port_group_refinement }*
[ inverse ofunique_port_group_type_reference ]
|
inverse
ofunique_port_group_type_reference
)
[ properties(
{ portgroup_property_association }+ | none_statement ) ]
{
annex_subclause }*
enddefining_identifier ;
--
declaring a port group as component feature
port_group_spec
::=
defining_port_group_identifier
: port group
[ unique_port_group_type_reference ]
[ { { portgroup_property_association }+} ] ;
port_group_refinement
::=
defining_port_group_identifier
: refined to
port
group [ unique_port_group_type_reference ]
[ { { portgroup_property_association }+} ] ;
unique_port_group_type_reference
::=
[ package_name :: ] port_group_type_identifier
data_subprogram_spec
::=
defining_subprogram_identifier
: subprogram
[ subprogram_classifier_reference ]
[ { { subprogram_property_association }+ } ] ;
data_subprogram_refinement
::=
defining_subprogram_identifier :
refined tosubprogram
[subprogram_classifier_reference
]
[ { { subprogram_property_association }+ } ] ;
server_subprogram_spec
::=
defining_subprogram_identifier
: serversubprogram
[ unique_subprogram_reference ]
[ {
{ subprogram_property_association }+ } ] ;
server_subprogram_refinement
::=
defining_subprogram_identifier
: refined to
server subprogram
[ unique_subprogram_reference ]
[ {
{ subprogram_property_association }+ } ] ;
unique_subprogram_reference
::=
subprogram_classifier_reference
| data_subprogram_feature_classifier_reference
data_subprogram_feature_classifier_reference
::=
[ package_name :: ] data_type_identifier . subprogram_identifier
parameter
::=
defining_parameter_identifier
:
( in | out | in out ) parameter [ data_classifier_reference ]
[ { { parameter_property_association }+} ] ;
parameter_refinement
::=
defining_parameter_identifier
: refined to
( in | out | in out ) parameter [ data_classifier_reference ]
[ { { parameter_property_association }+} ] ;
--
The requires and provides subcomponent access subclause
subcomponent_access
::=
defining_subcomponent_access_identifier
:
subcomponent_access_classifier
[ { { access_property_association }+ }] ;
subcomponent_access_refinement
::=
defining_subcomponent_access_identifier
: refined to
subcomponent_access_classifier
[ { { access_property_association }+ }] ;
subcomponent_access_classifier
::=
( provides | requires ) ( data | bus ) access
[ unique_component_type_identifier
[ . component_implementation_name ] ]
connection
::=
port_connection
| parameter_connection
| access_connection
connection_refinement
::=
port_connection_refinement
| parameter_connection_refinement
| access_connection_refinement
port_connection
::=
data_connection
| event_connection
| event_data_connection
| port_group_connection
data_connection
::=
[ defining_data_connection_identifier :]
data
portsource_unique_port_identifier
( immediate_connection_symbol | delayed_connection_symbol )
destination_unique_port_identifier
[ { { property_association }+ }]
[ in_modes_and_transitions ] ;
immediate_connection_symbol
::= ->
delayed_connection_symbol
::= ->>
event_connection
::=
[ defining_event_connection_identifier :]
event
portsource_unique_port_identifier
->destination_unique_port_identifier
[ { { property_association }+ }]
[ in_modes_and_transitions ] ;
event_data_connection
::=
[ defining_event_data_connection_identifier :]
event
data portsource_unique_port_identifier
-> destination_unique_port_identifier
[ { { property_association }+ }]
[ in_modes_and_transitions ] ;
--
connection between port groups of two subcomponents or between
--
a port group of a subcomponent and a port group in the component
type
port_group_connection
::=
[ defining_port_group_connection_identifier :]
port
groupsource_unique_port_group_identifier
-> destination_unique_port_group_identifier
[ { { property_association }+ }]
[ in_modes_and_transitions ] ;
port_connection_refinement
::=
connection_identifier
: refined to
( data port | event port | event data port | port group )
( ( { { property_association }+}
[ in_modes_and_transitions ] )
| in_modes_and_transitions
) ;
unique_port_identifier
::=
-- port in the component type
component_type_port_identifier
|
-- port in a subcomponent
subcomponent_identifier .port_identifier
|
-- port element in a port group of the component type
component_type_port_group_identifier
. element_port_identifier
unique_port_group_identifier
::=
-- port group in the component type
component_type_port_group_identifier
|
-- port group in a subcomponent
subcomponent_identifier .port_group_identifier
|
-- port group element in a port group of the component type
component_type_port_group_identifier
.
element_port_group_identifier
parameter_connection
::=
[ defining_parameter_connection_identifier :]
parametersource_unique_parameter_identifier
-> destination_unique_parameter_identifier
[ { { property_association }+ }]
[ in_modes ] ;
parameter_connection_refinement
::=
connection_identifier
: refined toparameter
{
{ property_association }+}
[ in_modes ] ;
unique_parameter_identifier
::=
-- parameter in the thread or subprogram type
component_type_parameter_identifier
|
-- parameter in another subprogram call
subprogram_call_identifier .parameter_identifier
|
-- data or even data port in the thread type of the component
type
component_type_port_identifier
|
-- port element in a port group of the component type
-- The port element must be a data or event data port
component_type_port_group_identifier
. element_port_identifier
access_connection
::=
[ access_connection_identifier :]
( bus | data ) accessunique_access_provider_identifier
->
unique_access_requirer_identifier
[ { { property_association }+ }]
[ in_modes ] ;
access_connection_refinement
::=
connection_identifier
: refined to ( bus | data ) access
{{
property_association }+ }
[ in_modes ] ;
unique_access_provider_identifier
::=
-- required access feature in the component type
component_type_access_identifier
|
-- provided access in a subcomponent
data_or_bus_subcomponent_identifier .access_identifier
|
-- data or bus subcomponent being accessed
data_or_bus_subcomponent_identifier
unique_access_requirer_identifier
::=
-- provided access feature in the component type
component_type_access_identifier
|
-- required access in a subcomponent
data_or_bus_subcomponent_identifier .access_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
sourceflow_feature_identifier
[ { { property_association }+ } ] ;
flow_sink_spec
::=
defining_flow_identifier : flow
sinkflow_feature_identifier
[ { { property_association }+ } ] ;
flow_path_spec
::=
defining_flow_identifier : flow
pathsource_flow_feature_identifier
->
sink_flow_feature_identifier
[ { { property_association }+ } ] ;
flow_source_spec_refinement
::=
defining_flow_identifier :
refined
to flow source { { property_association }+} ;
flow_sink_spec_refinement
::=
defining_flow_identifier :
refined
to flow sink { { property_association }+} ;
flow_path_spec_refinement
::=
defining_flow_identifier :
refined
to flow path { { property_association }+ };
flow_feature_identifier
::=
port_identifier
| parameter_identifier
| port_group_identifier
| port_group_identifier .port_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 ->}*
flow_feature_identifier
flow_sink_implementation
::=
flow_identifier
: flow sink
flow_feature_identifier
{ ->connection_identifier ->subcomponent_flow_identifier }*
flow_path_implementation
::=
flow_identifier
: flow path
source_flow_feature_identifier
[ { ->connection_identifier ->subcomponent_flow_identifier }+
-> connection_identifier
]
->sink_flow_feature_identifier
flow_implementation_refinement
::=
flow_source_implementation_refinement
| flow_sink_implementation_refinement
| flow_path_implementation_refinement
flow_source_implementation_refinement
::=
flow_identifier :
refined
to flow source
( {
{ property_association }+ } [ in_modes_and_transitions ]
|
in_modes_and_transitions
) ;
flow_sink_implementation_refinement
::=
flow_identifier :
refined
to flow sink
( {
{ property_association }+ } [ in_modes_and_transitions ]
|
in_modes_and_transitions
) ;
flow_path_implementation_refinement
::=
flow_identifier :
refined
to flow path
( {
{ property_association }+ } [ in_modes_and_transitions ]
|
in_modes_and_transitions
) ;
subcomponent_flow_identifier
::=
subcomponent_identifier .flow_spec_identifier
end_to_end_flow_spec
::=
defining_end_to_end_flow_identifier
: end to endflow
start_subcomponent_flow_identifier
{ ->connection_identifier
-> flow_path_subcomponent_flow_identifier
}*
->connection_identifier ->end_subcomponent_flow_identifier
[ { ( property_association }+ }]
[ in_modes_and_transitions ] ;
end_to_end_flow_refinement
::=
defining_end_to_end_identifier :
refined
to end to end flow
( {
{ property_association }+ } [ in_modes_and_transitions ]
|
in_modes_and_transitions
) ;
property_set
::=
property
set defining_property_set_identifier is
{ property_type_declaration
| property_name_declaration
| property_constant }+
end defining_property_set_identifier
;
property_type_declaration
::=
defining_property_type_identifier
: typeproperty_type_designator ;
property_type_designator
::=
property_type | unique_property_type_identifier
property_type
::=
aadlboolean
| aadlstring
| enumeration_type | units_type
| number_type | range_type
| classifier_type
| reference_type
enumeration_type
::=
enumeration
(defining_enumeration_literal_identifier
{ , defining_enumeration_literal_identifier }* )
units_type
::=
unitsunits_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
ofnumber_type
| range ofnumber_unique_property_type_identifier
classifier_type
::=
classifier [ ( component_category { , component_category }* ) ]
reference_type
::=
reference [ ( referable_element_category
{ , referable_element_category }* )]
referable_element_category
::=
component_category
| connections | server subprogram
unique_property_type_identifier
::=
[ property_set_identifier :: ] property_type_identifier
property_name_declaration
::=
defining_property_name_identifier
: [ access ] [ inherit ]
( single_valued_property | multi_valued_property )
applies
to (
(
property_owner_category { , property_owner_category }*
| all
)
)
;
single_valued_property
::=
property_type_designator [ =>default_property_expression ]
multi_valued_property
::=
list ofproperty_type_designator
[ =>
(
[ default_property_expression { ,default_property_expression }* ] )
]
property_owner_category
::=
component_category [ classifier_reference ]
| mode | port group | flow
| [ event ] [ data ] port
| server subprogram | parameter
| [ connection_type ] connections
connection_type
::=
port
group | [ event ] [ data ] port | access | parameter
property_constant
::=
single_valued_property_constant
| multi_valued_property_constant
single_valued_property_constant
::=
defining_property_constant_identifier :constant
( ( aadlinteger | aadlreal
[ units_unique_property_type_identifier
] )
| aadlstring
| aadlboolean
| enumeration_unique_property_type_identifier
| integer_range_unique_property_type_identifier
| real_range_unique_property_type_identifier
| integer_unique_property_type_identifer
| real_unique_property_type_identifer
)
=>
constant_property_value ;
multi_valued_property_constant
::=
defining_property_constant_identifier :constant list
of
( ( aadlinteger | aadlreal
[ units_unique_property_type_identifier
] )
| aadlstring
| aadlboolean
| enumeration_unique_property_type_identifier
| integer_range_unique_property_type_identifier
| real_range_unique_property_type_identifier
| integer_unique_property_type_identifer
| real_unique_property_type_identifer
)
=> (
[ constant_property_value { ,constant_property_value }* ]
);
constant_property_value
::=
string_literal
| signed_integer
| signed_real
| boolean_value
| enumeration_identifier
| signed_aadlinteger .. signed_aadlinteger [
deltasigned_aadlinteger ]
| signed_aadlreal .. signed_aadlreal [ deltasigned_aadlreal ]
unique_property_constant_identifier
::=
value
( [ property_set_identifier :: ]
property_constant_identifier )
property_association
::=
[ property_set_identifier :: ] property_name_identifier ( => | +=>
)
[ constant ] property_value
[ in_binding ]
[ in_modes ] ;
access_property_association
::=
[ property_set_identifier :: ] property_name_identifier ( => | +=>
)
[ constant ] access property_value
[ in_binding ]
[ in_modes ] ;
contained_property_association
::=
[ property_set_identifier :: ]
property_name_identifier
( => | +=>)
[ constant ] property_value
applies tocontained_unit_identifier { .contained_unit_identifier
}*
[ in_binding ]
[ in_modes ] ;
property_value
::= single_property_value | property_list_value
single_property_value
::= property_expression
property_list_value
::=
(
[ property_expression { , property_expression }* ] )
in_binding
::=
in
binding( platform_classifier_reference
{ , platform_classifier_reference }*)
platform_classifier_reference
::=
processor_classifier_reference
| memory_classifier_reference
| bus_classifer_reference
property_expression ::=
boolean_term
| real_term
| integer_term
| string_term
| enumeration_term
| real_range_term
| integer_range_term
| property_term
| component_classifier_term
| reference_term
boolean_term
::=
boolean_value
| boolean_property_constant_term
| not boolean_term
| boolean_term and boolean_term
| boolean_term or boolean_term
| ( boolean_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
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
::=
value
( [ property_set_identifier :: ] property_name_identifier )
property_constant_term
::=
value ( [ property_set_identifier :: ]
property_constant_identifier )
component_classifier_term ::=
component_category
[ unique_component_type_identifier
[ .component_implementation_identifier ] ]
reference_term
::=
reference
subcomponent_identifier
{ . subcomponent_identifier }*
|
{ subcomponent_identifier. }+ connection_identifier
| {subcomponent_identifier
. }+server_subprogram_identifier
NOTES:
Boolean operators
have the following decreasing precedence order: (),
not, and, or.
|
|||||||||||||||||||||||||||||||||||||