17. Syntax Summary
Informative
The AADL has the following restrictions on the constructs that are permitted in the component type and component implementation of each component category.
Category
Type
Implementation
data
Features:
  • subprogram
  • provides data access

Flow specifications: no
Properties: yes
Subcomponents:
  • data

Subprogram calls: no
Connections: access
Flows: no
Modes: yes
Properties: yes
subprogram
Features:
  • out event port
  • out event data port
  • port group
  • requires data access
  • parameter

Flow specifications: yes
Properties: yes
Subcomponents:
  • None

Subprogram calls: yes
Connections: yes
Flows: yes
Modes: yes
Properties: yes
thread
Features:
  • server subprogram
  • port
  • port group
  • provides data access
  • requires data access

Flow specifications: yes
Properties: yes
Subcomponents:
  • data

Subprogram calls: yes
Connections: thread
Flows: yes
Modes: yes
Properties: yes
thread group
Features:
  • server subprogram
  • port
  • port group
  • provides data access
  • requires data access

Flow specifications: yes
Properties: yes
Subcomponents:
  • data
  • thread
  • thread group

Subprogram calls: no
Connections: yes
Flows: yes
Modes: yes
Properties: yes
process
Features:
  • server subprogram
  • port
  • port group
  • provides data access
  • requires data access

Flow specifications: yes
Properties: yes
Subcomponents:
  • data
  • thread
  • thread group

Subprogram calls: no
Connections: yes
Flows: yes
Modes: yes
Properties: yes
 
processor
Features:
  • server subprogram
  • port
  • port group
  • requires bus access

Flow specifications: yes
Properties: yes
Subcomponents:
  • memory

Subprogram calls: no
Connections: no
Flows: yes
Modes: yes
Properties: yes
memory
Features:
  • requires bus access

Flow specifications: no
Properties: yes
Subcomponents:
  • memory

Subprogram calls: no
Connections: no
Flows: no
Modes: yes
Properties: yes
bus
Features:
  • requires bus access

Flow specifications: no
Properties: yes
Subcomponents:
  • None

Subprogram calls: no
Connections: no
Flows: no
Modes: yes
Properties: yes
device
Features:
  • port
  • port group
  • server subprogram
  • requires bus access

Flow specifications: yes
Properties: yes
Subcomponents:
  • None

Subprogram calls: no
Connections: no
Flows: yes
Modes: yes
Properties: yes
system
Features:
  • server  subprogram
  • port
  • port group
  • provides data access
  • provides bus access
  • requires data access
  • requires bus access

Flow specifications: yes
Properties: yes
Subcomponents:
  • data
  • process
  • processor
  • memory
  • device
  • bus
  • system

Subprogram calls: no
Connections: yes
Flows: yes
Modes: yes
Properties: yes
 
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 ::=
        ( providesrequires ) ( 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.