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