~~NOTOC~~
====== BNF ======
===== abstract_literal =====
<code bnf>
abstract_literal ::= decimal_literal | based_literal
</code>

===== access_type_definition =====
<code bnf>
access_type_definition ::= access subtype_indication
</code>

===== actual_designator =====
<code bnf>
actual_designator ::=
      expression
    | signal _name
    | variable _name
    | file _name
    | open
</code>

===== actual_parameter_part =====
<code bnf>
actual_parameter_part ::= parameter _association_list
</code>

===== actual_part =====
<code bnf>
actual_part ::=
      actual_designator
    | function _name ( actual_designator )
    | type_mark ( actual_designator )
</code>

===== adding_operator =====
<code bnf>
adding_operator ::= + | - | &
</code>

===== aggregate =====
<code bnf>
aggregate ::=
     ( element_association { , element_association } )
</code>

===== alias_declaration =====
<code bnf>
alias_declaration ::=
     alias alias_designator [ : subtype_indication ] is name [ signature ] ;
</code>

===== alias_designator =====
<code bnf>
alias_designator ::= identifier | character_literal | operator_symbol
</code>

===== allocator =====
<code bnf>
allocator ::=
      new subtype_indication
    | new qualified_expression
</code>

===== architecture_body =====
<code bnf>
architecture_body ::=
     architecture identifier of entity _name is
         architecture_declarative_part
    begin
             architecture_statement_part
    end [architecture] [ architecture _simple_name ] ;
</code>

===== architecture_declarative_part =====
<code bnf>
architecture_declarative_part ::=
     { block_declarative_item }
</code>

===== architecture_statement_part =====
<code bnf>
architecture_statement_part ::=
     { concurrent_statement }
</code>

===== array_type_definition =====
<code bnf>
array_type_definition ::=
     unconstrained_array_definition | constrained_array_definition
</code>

===== assertion =====
<code bnf>
assertion ::=
     assert condition
        [ report expression ]
        [ severity expression ]
</code>

===== assertion_statement =====
<code bnf>
assertion_statement ::= [ label : ] assertion ;
</code>

===== association_element =====
<code bnf>
association_element ::=
     [ formal_part => ] actual_part
</code>

===== association_list =====
<code bnf>
association_list ::=
     association_element { , association_element }
</code>

===== attribute_declaration =====
<code bnf>
attribute_declaration ::=
     attribute identifier : type_mark ;
</code>

===== attribute_designator =====
<code bnf>
attribute_designator ::= attribute _simple_name
</code>

===== attribute_name =====
<code bnf>
attribute_name ::=
     prefix [ signature ] ' attribute_designator [ ( expression ) ]
</code>

===== attribute_specification =====
<code bnf>
attribute_specification ::=
     attribute attribute_designator of entity_specification is expression ;
</code>

===== base =====
<code bnf>
base ::= integer
</code>

===== base_specifier =====
<code bnf>
base_specifier ::= B | O | X
</code>

===== based_integer =====
<code bnf>
based_integer ::=
     extended_digit { [ underline ] extended_digit }
</code>

===== based_literal =====
<code bnf>
based_literal ::=
     base # based_integer [ . based_integer ] # [ exponent ]
</code>

===== basic_character =====
<code bnf>
basic_character ::=
     basic_graphic_character | format_effector
</code>

===== basic_graphic_character =====
<code bnf>
basic_graphic_character ::=
     upper_case_letter | digit | special_character| space_character
</code>

===== basic_identifier =====
<code bnf>
basic_identifier ::= letter { [ underline ] letter_or_digit }
</code>

===== binding_indication =====
<code bnf>
binding_indication ::=
      [ use entity_aspect ]
    [ generic_map_aspect ]
    [ port_map_aspect ]
</code>

===== bit_string_literal =====
<code bnf>
bit_string_literal ::= base_specifier " [ bit_value ] "
</code>

===== bit_value =====
<code bnf>
bit_value ::= extended_digit { [ underline ] extended_digit }
</code>

===== block_configuration =====
<code bnf>
block_configuration ::=
     for block_specification
        { use_clause }
        { configuration_item }
    end for ;
</code>

===== block_declarative_item =====
<code bnf>
block_declarative_item ::=
      subprogram_declaration
    | subprogram_body
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | signal_declaration
    | shared _variable_declaration
    | file_declaration
    | alias_declaration
    | component_declaration
    | attribute_declaration
    | attribute_specification
    | configuration_specification
    | disconnection_specification
    | use_clause
    | group_template_declaration
    | group_ declaration
</code>

===== block_declarative_part =====
<code bnf>
block_declarative_part ::=
     { block_declarative_item }
</code>

===== block_header =====
<code bnf>
block_header ::=
      [ generic_clause
    [ generic_map_aspect ; ] ]
    [ port_clause
    [ port_map_aspect ; ] ]
</code>

===== block_specification =====
<code bnf>
block_specification ::=
      architecture _name
    | block_statement _label
    | generate_statement _label [ ( index_specification ) ]
</code>

===== block_statement =====
<code bnf>
block_statement ::=
      block _label :
        block [ ( guard _expression ) ] [ is ]
            block_header
            block_declarative_part
        begin
             block_statement_part
        end block [ block _label ] ;
</code>

===== block_statement_part =====
<code bnf>
block_statement_part ::=
     { concurrent_statement }
</code>

===== case_statement =====
<code bnf>
case_statement ::=
     case expression is
             case_statement_alternative
            { case_statement_alternative }
        end case [ case_label ] ;
</code>

===== case_statement_alternative =====
<code bnf>
case_statement_alternative ::=
     when choices =>
        sequence_of_statements
</code>

===== character_literal =====
<code bnf>
character_literal ::= ' graphic_character '
</code>

===== choice =====
<code bnf>
choice ::=
      simple_expression
    | discrete_range
    | element _simple_name
    | others
</code>

===== choices =====
<code bnf>
choices ::= choice { | choice }
</code>

===== component_configuration =====
<code bnf>
component_configuration ::=
     for component_specification
        [ binding_indication ; ]
        [ block_configuration ]
    end for ;
</code>

===== component_declaration =====
<code bnf>
component_declaration ::=
     component identifier [ is ]
        [ local _generic_clause ]
        [ local _port_clause ]
    end component [ component _simple_name ] ;
</code>

===== component_instantiation_statement =====
<code bnf>
component_instantiation_statement ::=
      instantiation _label :
         instantiated_unit
            [ generic_map_aspect ]
            [ port_map_aspect ] ;
</code>

===== component_specification =====
<code bnf>
component_specification ::=
     instantiation_list : component _name
</code>

===== composite_type_definition =====
<code bnf>
composite_type_definition ::=
      array_type_definition
    | record_type_definition
</code>

===== concurrent_assertion_statement =====
<code bnf>
concurrent_assertion_statement ::=
     [ label : ] [ postponed ] assertion ;
</code>

===== concurrent_procedure_call_statement =====
<code bnf>
concurrent_procedure_call_statement ::=
     [ label : ] [ postponed ] procedure_call ;
</code>

===== concurrent_signal_assignment_statement =====
<code bnf>
concurrent_signal_assignment_statement ::=
      [ label : ] [ postponed ] conditional_signal_assignment
    | [ label : ] [ postponed ] selected_signal_assignment
</code>

===== concurrent_statement =====
<code bnf>
concurrent_statement ::=
      block_statement
    | process_statement
    | concurrent_procedure_call_statement
    | concurrent_assertion_statement
    | concurrent_signal_assignment_statement
    | component_instantiation_statement
    | generate_statement
</code>

===== condition =====
<code bnf>
condition ::= boolean _expression
</code>

===== condition_clause =====
<code bnf>
condition_clause ::= until condition
</code>

===== conditional_signal_assignment =====
<code bnf>
conditional_signal_assignment ::=
     target <= options conditional_waveforms ;
</code>

===== conditional_waveforms =====
<code bnf>
conditional_waveforms ::=
     { waveform when condition else }
    waveform [ when condition ]
</code>

===== configuration_declaration =====
<code bnf>
configuration_declaration ::=
     configuration identifier of entity _name is
         configuration_declarative_part
        block_configuration
    end [ configuration ] [ configuration _simple_name ] ;
</code>

===== configuration_declarative_item =====
<code bnf>
configuration_declarative_item ::=
      use_clause
    | attribute_specification
    | group_ declaration
</code>

===== configuration_declarative_part =====
<code bnf>
configuration_declarative_part ::=
     { configuration_declarative_item }
</code>

===== configuration_item =====
<code bnf>
configuration_item ::=
      block_configuration
    | component_configuration
</code>

===== configuration_specification =====
<code bnf>
configuration_specification ::=
     for component_specification binding_indication ;
</code>

===== constant_declaration =====
<code bnf>
constant_declaration ::=
     constant identifier_list : subtype_indication [ := expression ] ;
</code>

===== constrained_array_definition =====
<code bnf>
constrained_array_definition ::=
     array index_constraint of element _subtype_indication
</code>

===== constraint =====
<code bnf>
constraint ::=
      range_constraint
    | index_constraint
</code>

===== context_clause =====
<code bnf>
context_clause ::= { context_item }
</code>

===== context_item =====
<code bnf>
context_item ::=
      library_clause
    | use_clause
</code>

===== decimal_literal =====
<code bnf>
decimal_literal ::= integer [ . integer ] [ exponent ]
</code>

===== declaration =====
<code bnf>
declaration ::=
      type_declaration
    | subtype_declaration
    | object_declaration
    | interface_declaration
    | alias_declaration
    | attribute_declaration
    | component_declaration
    | group_template_declaration
    | group_ declaration
    | entity_declaration
    | configuration_declaration
    | subprogram_declaration
    | package_declaration
</code>

===== delay_mechanism =====
<code bnf>
delay_mechanism ::=
      transport
     | [ reject time _expression ] inertial
</code>

===== design_file =====
<code bnf>
design_file ::= design_unit { design_unit }
</code>

===== design_unit =====
<code bnf>
design_unit ::= context_clause library_unit
</code>

===== designator =====
<code bnf>
designator ::= identifier | operator_symbol
</code>

===== direction =====
<code bnf>
direction ::= to | downto
</code>

===== disconnection_specification =====
<code bnf>
disconnection_specification ::=
     disconnect guarded_signal_specification after time _expression ;
</code>

===== discrete_range =====
<code bnf>
discrete_range ::= discrete _subtype_indication | range
</code>

===== element_association =====
<code bnf>
element_association ::=
[ choices => ] expression
</code>

===== element_declaration =====
<code bnf>
element_declaration ::=
     identifier_list : element_subtype_definition ;
</code>

===== element_subtype_definition =====
<code bnf>
element_subtype_definition ::= subtype_indication
</code>

===== entity_aspect =====
<code bnf>
entity_aspect ::=
      entity entity _name [ ( architecture _identifier) ]
    | configuration configuration _name
    | open
</code>

===== entity_class =====
<code bnf>
entity_class ::=
      entity
    | architecture
    | configuration
    | procedure
    | function
    | package
    | type
    | subtype
    | constant
    | signal
    | variable
    | component
    | label
    | literal
    | units
    | group
    | file
</code>

===== entity_class_entry =====
<code bnf>
entity_class_entry ::= entity_class [ <> ]
</code>

===== entity_class_entry_list =====
<code bnf>
entity_class_entry_list ::=
     entity_class_entry { , entity_class_entry }
</code>

===== entity_declaration =====
<code bnf>
entity_declaration ::=
     entity identifier is
         entity_header
        entity_declarative_part
    [ begin
         entity_statement_part ]
    end [ entity ] [ entity _simple_name ] ;
</code>

===== entity_declarative_item =====
<code bnf>
entity_declarative_item ::=
      subprogram_declaration
    | subprogram_body
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | signal_declaration
    | shared _variable_declaration
    | file_declaration
    | alias_declaration
    | attribute_declaration
    | attribute_specification
    | disconnection_specification
    | use_clause
    | group_template_declaration
    | group_ declaration
</code>

===== entity_declarative_part =====
<code bnf>
entity_declarative_part ::=
     { entity_declarative_item }
</code>

===== entity_designator =====
<code bnf>
entity_designator ::= entity_tag [ signature ]
</code>

===== entity_header =====
<code bnf>
entity_header ::=
      [ formal _generic_clause ]
    [ formal _port_clause ]
</code>

===== entity_name_list =====
<code bnf>
entity_name_list ::=
      entity_designator { , entity_designator }
    | others
     | all
</code>

===== entity_specification =====
<code bnf>
entity_specification ::=
     entity_name_list : entity_class
</code>

===== entity_statement =====
<code bnf>
entity_statement ::=
      concurrent_assertion_statement
    | passive _concurrent_procedure_call_statement
    | passive _process_statement
</code>

===== entity_statement_part =====
<code bnf>
entity_statement_part ::=
     { entity_statement }
</code>

===== entity_tag =====
<code bnf>
entity_tag ::= simple_name | character_literal | operator_symbol
</code>

===== enumeration_literal =====
<code bnf>
enumeration_literal ::= identifier | character_literal
</code>

===== enumeration_type_definition =====
<code bnf>
enumeration_type_definition ::=
     ( enumeration_literal { , enumeration_literal } )
</code>

===== exit_statement =====
<code bnf>
exit_statement ::=
     [ label : ] exit [ loop _label ] [ when condition ] ;
</code>

===== exponent =====
<code bnf>
exponent ::= E [ + ] integer | E -integer
</code>

===== expression =====
<code bnf>
expression ::=
      relation { and relation }
    | relation { or relation }
    | relation { xor relation }
    | relation [ nand relation ]
    | relation [ nor relation ]
    | relation { xnor relation }
</code>

===== extended_digit =====
<code bnf>
extended_digit ::= digit | letter
</code>

===== extended_identifier =====
<code bnf>
extended_identifier ::= \ graphic_character { graphic_character } \
</code>

===== factor =====
<code bnf>
factor ::=
      primary [ ** primary ]
    | abs primary
    | not primary
</code>

===== file_declaration =====
<code bnf>
file_declaration ::=
     file identifier_list : subtype_indication [ file_open_information ] ;
</code>

===== file_logical_name =====
<code bnf>
file_logical_name ::= string _expression
</code>

===== file_open_information =====
<code bnf>
file_open_information ::=
     [ open file_open_kind _expression ] is file_logical_name
</code>

===== file_type_definition =====
<code bnf>
file_type_definition ::=
     file of type_mark
</code>

===== floating_type_definition =====
<code bnf>
floating_type_definition ::= range_constraint
</code>

===== formal_designator =====
<code bnf>
formal_designator ::=
      generic _name
    | port _name
    | parameter _name
</code>

===== formal_parameter_list =====
<code bnf>
formal_parameter_list ::= parameter _interface_list
</code>

===== formal_part =====
<code bnf>
formal_part ::=
      formal_designator
    | function _name ( formal_designator )
    | type_mark ( formal_designator )
</code>

===== full_type_declaration =====
<code bnf>
full_type_declaration ::=
     type identifier is type_definition ;
</code>

===== function_call =====
<code bnf>
function_call ::=
      function _name [ ( actual_parameter_part ) ]
</code>

===== generate_statement =====
<code bnf>
generate_statement ::=
      generate _label :
        generation_scheme generate
             [ { block_declarative_item }
        begin ]
            { concurrent_statement }
        end generate [ generate _label ] ;
</code>

===== generation_scheme =====
<code bnf>
generation_scheme ::=
     for generate _parameter_specification
    | if condition
</code>

===== generic_clause =====
<code bnf>
generic_clause ::=
     generic ( generic_list ) ;
</code>

===== generic_list =====
<code bnf>
generic_list ::= generic _interface_list
</code>

===== generic_map_aspect =====
<code bnf>
generic_map_aspect ::=
     generic map ( generic _association_list )
</code>

===== graphic_character =====
<code bnf>
graphic_character ::=
     basic_graphic_character | lower_case_letter | other_special_character
</code>

===== group_constituent =====
<code bnf>
group_constituent ::= name | character_literal
</code>

===== group_constituent_list =====
<code bnf>
group_constituent_list ::= group_constituent { , group_constituent }
</code>

===== group_declaration =====
<code bnf>
group_ declaration ::=
     group identifier : group_ template _name ( group_constituent_list ) ;
</code>

===== group_template_declaration =====
<code bnf>
group_template_declaration ::=
     group identifier is ( entity_class_entry_list ) ;
</code>

===== guarded_signal_specification =====
<code bnf>
guarded_signal_specification ::=
      guarded _signal_list : type_mark
</code>

===== identifier =====
<code bnf>
identifier ::= basic_identifier | extended_identifier
</code>

===== identifier_list =====
<code bnf>
identifier_list ::= identifier { , identifier }
</code>

===== if_statement =====
<code bnf>
if_statement ::=
     [ if _label : ]
        if condition then
             sequence_of_statements
        { elsif condition then
             sequence_of_statements }
        [ else
             sequence_of_statements ]
        end if [ if _label ] ;
</code>

===== incomplete_type_declaration =====
<code bnf>
incomplete_type_declaration ::= type identifier ;
</code>

===== index_constraint =====
<code bnf>
index_constraint ::= ( discrete_range { , discrete_range } )
</code>

===== index_specification =====
<code bnf>
index_specification ::=
      discrete_range
    | static _expression
</code>

===== index_subtype_definition =====
<code bnf>
index_subtype_definition ::= type_mark range <>
</code>

===== indexed_name =====
<code bnf>
indexed_name ::= prefix ( expression { , expression } )
</code>

===== instantiated_unit =====
<code bnf>
instantiated_unit ::=
      [ component ] component _name
    | entity entity _name [ ( architecture _identifier ) ]
    | configuration configuration _name
</code>

===== instantiation_list =====
<code bnf>
instantiation_list ::=
      instantiation _label { , instantiation _label }
    | others
     | all
</code>

===== integer =====
<code bnf>
integer ::= digit { [ underline ] digit }
</code>

===== integer_type_definition =====
<code bnf>
integer_type_definition ::= range_constraint
</code>

===== interface_constant_declaration =====
<code bnf>
interface_constant_declaration ::=
     [ constant ] identifier_list : [ in ] subtype_indication [ := static _expression ]
</code>

===== interface_declaration =====
<code bnf>
interface_declaration ::=
      interface_constant_declaration
    | interface_signal_declaration
    | interface_variable_declaration
    | interface_file_declaration
</code>

===== interface_element =====
<code bnf>
interface_element ::= interface_declaration
</code>

===== interface_file_declaration =====
<code bnf>
interface_file_declaration ::=
     file identifier_list : subtype_indication
</code>

===== interface_list =====
<code bnf>
interface_list ::=
     interface_element { ; interface_element }
</code>

===== interface_signal_declaration =====
<code bnf>
interface_signal_declaration ::=
     [ signal ] identifier_list : [ mode ] subtype_indication [ bus ] [ := static _expression ]
</code>

===== interface_variable_declaration =====
<code bnf>
interface_variable_declaration ::=
     [ variable ] identifier_list : [ mode ] subtype_indication [ := static _expression ]
</code>

===== iteration_scheme =====
<code bnf>
iteration_scheme ::=
      while condition
    | for loop _parameter_specification
</code>

===== label =====
<code bnf>
label ::= identifier
</code>

===== letter =====
<code bnf>
letter ::= upper_case_letter | lower_case_letter
</code>

===== letter_or_digit =====
<code bnf>
letter_or_digit ::= letter | digit
</code>

===== library_clause =====
<code bnf>
library_clause ::= library logical_name_list ;
</code>

===== library_unit =====
<code bnf>
library_unit ::=
      primary_unit
    | secondary_unit
</code>

===== literal =====
<code bnf>
literal ::=
      numeric_literal
    | enumeration_literal
    | string_literal
    | bit_string_literal
    | null
</code>

===== logical_name =====
<code bnf>
logical_name ::= identifier
</code>

===== logical_name_list =====
<code bnf>
logical_name_list ::= logical_name { , logical_name }
</code>

===== logical_operator =====
<code bnf>
logical_operator ::= and | or | nand | nor | xor | xnor
</code>

===== loop_statement =====
<code bnf>
loop_statement ::=
     [ loop _label : ]
        [ iteration_scheme ] loop
             sequence_of_statements
        end loop [ loop _label ] ;
</code>

===== miscellaneous_operator =====
<code bnf>
miscellaneous_operator ::= ** | abs | not
</code>

===== mode =====
<code bnf>
mode ::= in | out | inout | buffer | linkage
</code>

===== multiplying_operator =====
<code bnf>
multiplying_operator ::= * | / | mod | rem
</code>

===== name =====
<code bnf>
name ::=
      simple_name
    | operator_symbol
    | selected_name
    | indexed_name
    | slice_name
    | attribute_name
</code>

===== next_statement =====
<code bnf>
next_statement ::=
     [ label : ] next [ loop _label ] [ when condition ] ;
</code>

===== null_statement =====
<code bnf>
null_statement ::= [ label : ] null ;
</code>

===== numeric_literal =====
<code bnf>
numeric_literal ::=
      abstract_literal
    | physical_literal
</code>

===== object_declaration =====
<code bnf>
object_declaration ::=
      constant_declaration
    | signal_declaration
    | variable_declaration
    | file_declaration
</code>

===== operator_symbol =====
<code bnf>
operator_symbol ::= string_literal
</code>

===== options =====
<code bnf>
options ::= [ guarded ] [ delay_mechanism ]
</code>

===== package_body =====
<code bnf>
package_body ::=
     package body package _simple_name is
         package_body_declarative_part
    end [ package_body ] [ package _simple_name ] ;
</code>

===== package_body_declarative_item =====
<code bnf>
package_body_declarative_item ::=
      subprogram_declaration
    | subprogram_body
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | shared _variable_declaration
    | file_declaration
    | alias_declaration
    | use_clause
    | group_template_declaration
    | group_ declaration
</code>

===== package_body_declarative_part =====
<code bnf>
package_body_declarative_part ::=
     { package_body_declarative_item }
</code>

===== package_declaration =====
<code bnf>
package_declaration ::=
     package identifier is
         package_declarative_part
    end [ package ] [ package _simple_name ] ;
</code>

===== package_declarative_item =====
<code bnf>
package_declarative_item ::=
      subprogram_declaration
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | signal_declaration
    | shared _variable_declaration
    | file_declaration
    | alias_declaration
    | component_declaration
    | attribute_declaration
    | attribute_specification
    | disconnection_specification
    | use_clause
    | group_template_declaration
    | group_ declaration
</code>

===== package_declarative_part =====
<code bnf>
package_declarative_part ::=
     { package_declarative_item }
</code>

===== parameter_specification =====
<code bnf>
parameter_specification ::=
     identifier in discrete_range
</code>

===== physical_literal =====
<code bnf>
physical_literal ::= [ abstract_literal ] unit _name
</code>

===== physical_type_definition =====
<code bnf>
physical_type_definition ::=
     range_constraint
        units
             base_unit_declaration
            { secondary_unit_declaration }
        end units [ physical_type _simple_name ]
</code>

===== port_clause =====
<code bnf>
port_clause ::=
     port ( port_list ) ;
</code>

===== port_list =====
<code bnf>
port_list ::= port _interface_list
</code>

===== port_map_aspect =====
<code bnf>
port_map_aspect ::=
     port map ( port _association_list )
</code>

===== prefix =====
<code bnf>
prefix ::=
      name
    | function_call
</code>

===== primary =====
<code bnf>
primary ::=
      name
    | literal
    | aggregate
    | function_call
    | qualified_expression
    | type_conversion
    | allocator
    | ( expression )
</code>

===== primary_unit =====
<code bnf>
primary_unit ::=
      entity_declaration
    | configuration_declaration
    | package_declaration
</code>

===== primary_unit_declaration =====
<code bnf>
primary_unit_declaration ::= identifier ;
</code>

===== procedure_call =====
<code bnf>
procedure_call ::=
      procedure _name [ ( actual_parameter_part ) ]
</code>

===== procedure_call_statement =====
<code bnf>
procedure_call_statement ::= [ label : ] procedure_call ;
</code>

===== process_declarative_item =====
<code bnf>
process_declarative_item ::=
      subprogram_declaration
    | subprogram_body
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | variable_declaration
    | file_declaration
    | alias_declaration
    | attribute_declaration
    | attribute_specification
    | use_clause
    | group_template_declaration
    | group_ declaration
</code>

===== process_declarative_part =====
<code bnf>
process_declarative_part ::=
     { process_declarative_item }
</code>

===== process_statement =====
<code bnf>
process_statement ::=
      [ process _label : ]
        [ postponed ] process [ ( sensitivity_list ) ] [ is ]
            process_declarative_part
        begin
             process_statement_part
        end [ postponed ] process [ process _label ] ;
</code>

===== process_statement_part =====
<code bnf>
process_statement_part ::=
     { sequential_statement }
</code>

===== qualified_expression =====
<code bnf>
qualified_expression ::=
    type_mark ' ( expression )
    | type_mark ' aggregate
</code>

===== range =====
<code bnf>
range ::=
      range _attribute_name
    | simple_expression direction simple_expression
</code>

===== range_constraint =====
<code bnf>
range_constraint ::= range range
</code>

===== record_type_definition =====
<code bnf>
record_type_definition ::=
     record
         element_declaration
        { element_declaration }
    end record [ record_type _simple_name ]
</code>

===== relation =====
<code bnf>
relation ::=
     shift_expression [ relational_operator shift_expression ]
</code>

===== relational_operator =====
<code bnf>
relational_operator ::= = | /= | < | <= | > | >=
</code>

===== report_statement =====
<code bnf>
report_statement ::=
    [ label : ]
        report expression
            [ severity expression ] ;
</code>

===== return_statement =====
<code bnf>
return_statement ::=     [ label ] return [ expression ] ;
</code>

===== scalar_type_definition =====
<code bnf>
scalar_type_definition ::=
      enumeration_type_definition
    | integer_type_definition
    | floating_type_definition
    | physical_type_definition
</code>

===== secondary_unit =====
<code bnf>
secondary_unit ::=
      architecture_body
    | package_body
</code>

===== secondary_unit_declaration =====
<code bnf>
secondary_unit_declaration ::= identifier = physical_literal ;
</code>

===== selected_name =====
<code bnf>
selected_name ::= prefix . suffix
</code>

===== selected_signal_assignment =====
<code bnf>
selected_signal_assignment ::=
     with expression select
         target <= options selected_waveforms ;
</code>

===== selected_waveforms =====
<code bnf>
selected_waveforms ::=
     { waveform when choices , }
    waveform when choices
</code>

===== sensitivity_clause =====
<code bnf>
sensitivity_clause ::= on sensitivity_list
</code>

===== sensitivity_list =====
<code bnf>
sensitivity_list ::= signal _name { , signal _name }
</code>

===== sequence_of_statements =====
<code bnf>
sequence_of_statements ::=
     { sequential_statement }
</code>

===== sequential_statement =====
<code bnf>
sequential_statement ::=
      wait_statement
    | assertion_statement
    | report_statement
    | signal_assignment_statement
    | variable_assignment_statement
    | procedure_call_statement
    | if_statement
    | case_statement
    | loop_statement
    | next_statement
    | exit_statement
    | return_statement
    | null_statement
</code>

===== shift_expression =====
<code bnf>
shift_expression ::=
     simple_expression [ shift_operator simple_expression ]
</code>

===== shift_operator =====
<code bnf>
shift_operator ::= sll | srl | sla | sra | rol | ror
</code>

===== sign =====
<code bnf>
sign ::= + | -
</code>

===== signal_assignment_statement =====
<code bnf>
signal_assignment_statement ::=
     [ label : ] target <= [ delay_mechanism ] waveform ;
</code>

===== signal_declaration =====
<code bnf>
signal_declaration ::=
     signal identifier_list : subtype_indication [ signal_kind ] [ := expression ] ;
</code>

===== signal_kind =====
<code bnf>
signal_kind ::= register | bus
</code>

===== signal_list =====
<code bnf>
signal_list ::=
      signal _name { , signal _name }
    | others
     | all
</code>

===== signature =====
<code bnf>
signature ::= [ [ type_mark { , type_mark } ] [ return type_mark ] ]
</code>

===== simple_expression =====
<code bnf>
simple_expression ::=
     [ sign ] term { adding_operator term }
</code>

===== simple_name =====
<code bnf>
simple_name ::= identifier
</code>

===== slice_name =====
<code bnf>
slice_name ::= prefix ( discrete_range )
</code>

===== string_literal =====
<code bnf>
string_literal ::= " { graphic_character } "
</code>

===== subprogram_body =====
<code bnf>
subprogram_body ::=
     subprogram_specification is
         subprogram_declarative_part
    begin
         subprogram_statement_part
    end [ subprogram_kind ] [ designator ] ;
</code>

===== subprogram_declaration =====
<code bnf>
subprogram_declaration ::=
     subprogram_specification ;
</code>

===== subprogram_declarative_item =====
<code bnf>
subprogram_declarative_item ::=
      subprogram_declaration
    | subprogram_body
    | type_declaration
    | subtype_declaration
    | constant_declaration
    | variable_declaration
    | file_declaration
    | alias_declaratio
    | attribute_declaration
    | attribute_specification
    | use_clause
    | group_template_declaration
    | group_ declaratio
</code>

===== subprogram_declarative_part =====
<code bnf>
subprogram_declarative_part ::=
     { subprogram_declarative_item }
</code>

===== subprogram_kind =====
<code bnf>
subprogram_kind ::= procedure | function
</code>

===== subprogram_specification =====
<code bnf>
subprogram_specification ::=
     procedure designator [ ( formal_parameter_list ) ]
    | [ pure | impure ] function designator [ ( formal_parameter_list ) ]
        return type_mark
</code>

===== subprogram_statement_part =====
<code bnf>
subprogram_statement_part ::=
     { sequential_statement }
</code>

===== subtype_declaration =====
<code bnf>
subtype_declaration ::=
     subtype identifier is subtype_indication ;
</code>

===== subtype_indication =====
<code bnf>
subtype_indication ::=
     [ resolution_function _name ] type_mark [ constraint ]
</code>

===== suffix =====
<code bnf>
suffix ::=
      simple_name
    | character_literal
    | operator_symbol
    | all
</code>

===== target =====
<code bnf>
target ::=
      name
    | aggregate
</code>

===== term =====
<code bnf>
term ::=
     factor { multiplying_operator factor }
</code>

===== timeout_clause =====
<code bnf>
timeout_clause ::= for time _expression
</code>

===== type_conversion =====
<code bnf>
type_conversion ::= type_mark ( expression )
</code>

===== type_declaration =====
<code bnf>
type_declaration ::=
      full_type_declaration
    | incomplete_type_declaration
</code>

===== type_definition =====
<code bnf>
type_definition ::=
      scalar_type_definition
    | composite_type_definition
    | access_type_definition
    | file_type_definition
</code>

===== type_mark =====
<code bnf>
type_mark ::=
      type _name
    | subtype _name
</code>

===== unconstrained_array_definition =====
<code bnf>
unconstrained_array_definition ::=
     array ( index_subtype_definition { , index_subtype_definition } )
        of element _subtype_indication
</code>

===== use_clause =====
<code bnf>
use_clause ::=
     use selected_name { , selected_name } ;
</code>

===== variable_assignment_statement =====
<code bnf>
variable_assignment_statement ::=
     [ label : ] target := expression ;
</code>

===== variable_declaration =====
<code bnf>
variable_declaration ::=
     [ shared ] variable identifier_list : subtype_indication [ := expression ] ;
</code>

===== wait_statement =====
<code bnf>
wait_statement ::=
     [ label : ] wait [ sensitivity_clause ] [ condition_clause ] [ timeout_clause ] ;
</code>

===== waveform =====
<code bnf>
waveform ::=
      waveform_element { , waveform_element }
    | unaffected
</code>

===== waveform_element =====
<code bnf>
waveform_element ::=
      value _expression [ after time _expression ]
    | null [ after time _expression ]
</code>