VHDL - (BNF) Backus Naur Form

prepared by P. Bakowski



reserved words for VHDL'87


abstract_literal ::= decimal_literal | based_literal

access_type_definition ::= access subtype_indication

actual_designator ::=
expression
| signal_name
| variable_name
| file_name
| open

actual_parameter_part
::= parameter_association_list

actual_part ::=
actual_designator
| function_name ( actual_designator )
| type_mark ( actual_designator )

adding_operator ::= + | - | &

aggregate ::=
( element_association { , element_association } )

alias_declaration ::=
alias alias_designator [ : subtype_indication ] is name [ signature ] ;

alias_designator ::= identifier | character_literal | operator_symbol

allocator ::=
new subtype_indication
| new qualified_expression

architecture_body ::=
architecture identifier of entity_name is
architecture_declarative_part
begin
architecture_statement_part
end [ architecture ] [ architecture_simple_name ] ;

architecture_declarative_part ::=
{ block_declarative_item }

architecture_statement_part ::=
{ concurrent_statement }

array_type_definition ::=
unconstrained_array_definition | constrained_array_definition

assertion ::=
assert condition
[ report expression ]
[ severity expression ]

assertion_statement ::= [ label : ] assertion ;

association_element ::=
[ formal_part => ] actual_part

association_list ::=
association_element { , association_element }

attribute_declaration ::=
attribute identifier : type_mark ;

attribute_designator ::= attribute_simple_name

attribute_name ::=
prefix [ signature ] ' attribute_designator [ ( expression ) ]

attribute_specification ::=
attribute attribute_designator of entity_specification is expression ;

base ::= integer

base_specifier ::= B | O | X

base_unit_declaration ::= identifier ;

based_integer ::=
extended_digit { [ underline ] extended_digit }

based_literal ::=
base # based_integer [ . based_integer ] # [ exponent ]

basic_character ::=
basic_graphic_character | format_effector

basic_graphic_character ::=
upper_case_letter | digit | special_character| space_character

basic_identifier ::=
letter { [ underline ] letter_or_digit }

binding_indication ::=
[ use entity_aspect ]
[ generic_map_aspect ]
[ port_map_aspect ]

bit_string_literal ::= base_specifier " bit_value "

bit_value ::= extended_digit { [ underline ] extended_digit }

block_configuration ::=
for block_specification
{ use_clause }
{ configuration_item }
end for ;

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

block_declarative_part ::=
{ block_declarative_item }

block_header ::=
[ generic_clause
[ generic_map_aspect ; ] ]
[ port_clause
[ port_map_aspect ; ] ]

block_specification ::=
architecture_name
| block_statement_label
| generate_statement_label [ ( index_specification ) ]

block_statement ::=
block_label :
block [ ( guard_expression ) ] [ is ]
block_header
block_declarative_part
begin
block_statement_part
end block [ block_label ] ;

block_statement_part ::=
{ concurrent_statement }

case_statement ::=
[ case_label : ]
case expression is
case_statement_alternative
{ case_statement_alternative }
end case [ case_label ] ;

case_statement_alternative ::=
when choices =>
sequence_of_statements

character_literal ::= ' graphic_character '

choice ::=
simple_expression
| discrete_range
| element_simple_name
| others

choices
::= choice { | choice }

component_configuration ::=
for component_specification
[ binding_indication ; ]
[ block_configuration ]
end for ;

component_declaration ::=
component identifier [ is ]
[ local_generic_clause ]
[ local_port_clause ]
end component [ component_simple_name ] ;

component_instantiation_statement ::=
instantiation_label :
instantiated_unit
[ generic_map_aspect ]
[ port_map_aspect ] ;

component_specification ::=
instantiation_list : component_name

composite_type_definition ::=
array_type_definition
| record_type_definition

concurrent_assertion_statement ::=
[ label : ] [ postponed ] assertion ;

concurrent_procedure_call_statement ::=
[ label : ] [ postponed ] procedure_call ;

concurrent_signal_assignment_statement ::=
[ label : ] [ postponed ] conditional_signal_assignment
| [ label : ] [ postponed ] selected_signal_assignment

concurrent_statement ::=
block_statement
| process_statement
| concurrent_procedure_call_statement
| concurrent_assertion_statement
| concurrent_signal_assignment_statement
| component_instantiation_statement
| generate_statement

condition ::= boolean_expression

condition_clause ::= until condition

conditional_signal_assignment ::=
target <= options conditional_waveforms ;

conditional_waveforms ::=
{ waveform when condition else }
waveform [ when condition ]

configuration_declaration ::=
configuration identifier of entity_name is
configuration_declarative_part
block_configuration
end [ configuration ] [ configuration_simple_name ] ;

configuration_declarative_item ::=
use_clause
| attribute_specification
| group_declaration

configuration_declarative_part ::=
{ configuration_declarative_item }

configuration_item ::=
block_configuration
| component_configuration

configuration_specification ::=
for component_specification binding_indication ;

constant_declaration ::=
constant identifier_list : subtype_indication [ := expression ] ;

constrained_array_definition ::=
array index_constraint of element_subtype_indication

constraint ::=
range_constraint
| index_constraint

context_clause ::= { context_item }

context_item ::=
library_clause
| use_clause

decimal_literal ::= integer [ . integer ] [ exponent ]

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

delay_mechanism ::=
transport
| [ reject time_expression ] inertial

design_file ::= design_unit { design_unit }

design_unit ::= context_clause library_unit

designator ::= identifier | operator_symbol

direction ::= to | downto

disconnection_specification
::=
disconnect guarded_signal_specification after time_expression ;

discrete_range ::= discrete_subtype_indication | range

element_association
::=
[ choices => ] expression

element_declaration ::=
identifier_list : element_subtype_definition ;

element_subtype_definition ::= subtype_indication

entity_aspect ::=
entity entity_name [ ( architecture_identifier) ]
| configuration configuration_name
| open

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

entity_class_entry
::= entity_class [ <> ]

entity_class_entry_list ::=
entity_class_entry { , entity_class_entry }

entity_declaration ::=
entity identifier is
entity_header
entity_declarative_part
[ begin
entity_statement_part ]
end [ entity ] [ entity_simple_name ] ;

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

entity_declarative_part ::=
{ entity_declarative_item }

entity_designator ::= entity_tag [ signature ]

entity_header ::=
[ formal_generic_clause ]
[ formal_port_clause ]

entity_name_list ::=
entity_designator { , entity_designator }
| others
| all

entity_specification
::=
entity_name_list : entity_class

entity_statement ::=
concurrent_assertion_statement
| passive_concurrent_procedure_call_statement
| passive_process_statement

entity_statement_part ::=
{ entity_statement }

entity_tag ::= simple_name | character_literal | operator_symbol

enumeration_literal ::= identifier | character_literal

enumeration_type_definition ::=
( enumeration_literal { , enumeration_literal } )

exit_statement ::=
[ label : ] exit [ loop_label ] [ when condition ] ;

exponent ::= E [ + ] integer | E - integer

expression ::=
relation { and relation }
| relation { or relation }
| relation { xor relation }
| relation [ nand relation ]
| relation [ nor relation ]
| relation { xnor relation }

extended_digit ::= digit | letter

extended_identifier ::=
\ graphic_character { graphic_character } \

factor ::=
primary [ ** primary ]
| abs primary
| not primary

file_declaration ::=
file identifier_list : subtype_indication file_open_information ] ;

file_logical_name ::= string_expression

file_open_information ::=
[ open file_open_kind_expression ] is file_logical_name

file_type_definition ::=
file of type_mark

floating_type_definition := range_constraint

formal_designator ::=
generic_name
| port_name
| parameter_name

formal_parameter_list ::= parameter_interface_list

formal_part ::=
formal_designator
| function_name ( formal_designator )
| type_mark ( formal_designator )

full_type_declaration ::=
type identifier is type_definition ;

function_call ::=
function_name [ ( actual_parameter_part ) ]

generate_statement ::=
generate_label :
generation_scheme generate
[ { block_declarative_item }
begin ]
{ concurrent_statement }
end generate [ generate_label ] ;

generation_scheme ::=
for generate_parameter_specification
| if condition

generic_clause ::=
generic ( generic_list ) ;

generic_list ::= generic_interface_list

generic_map_aspect ::=
generic map ( generic_association_list )

graphic_character ::=
basic_graphic_character | lower_case_letter | other_special_character

group_constituent ::= name | character_literal

group_constituent_list ::= group_constituent { , group_constituent }

group_template_declaration ::=
group identifier is ( entity_class_entry_list ) ;

group_declaration ::=
group identifier : group_template_name ( group_constituent_list ) ;

guarded_signal_specification ::=
guarded_signal_list : type_mark

identifier ::=
basic_identifier | extended_identifier

identifier_list ::= identifier { , identifier }

if_statement ::=
[ if_label : ]
if condition then
sequence_of_statements
{ elsif condition then
sequence_of_statements }
[ else
sequence_of_statements ]
end if [ if_label ] ;

incomplete_type_declaration ::= type identifier ;

index_constraint ::= ( discrete_range { , discrete_range } )

index_specification ::=
discrete_range
| static_expression

index_subtype_definition ::= type_mark range <>

indexed_name ::= prefix ( expression { , expression } )

instantiated_unit ::=
[ component ] component_name
| entity entity_name [ ( architecture_identifier ) ]
| configuration configuration_name

instantiation_list ::=
instantiation_label { , instantiation_label }
| others
| all

integer
::= digit { [ underline ] digit }

integer_type_definition ::= range_constraint

interface_constant_declaration ::=
[ constant ] identifier_list : [ in ] subtype_indication [ := static_expression ]

interface_declaration ::=
interface_constant_declaration
| interface_signal_declaration
| interface_variable_declaration
| interface_file_declaration

interface_element ::= interface_declaration

interface_file_declaration ::=
file identifier_list : subtype_indication

interface_list ::=
interface_element { ; interface_element }

interface_signal_declaration ::=
[signal] identifier_list : [ mode ] subtype_indication [ bus ] [ := static_expression ]

interface_variable_declaration ::=
[variable] identifier_list : [ mode ] subtype_indication [ := static_expression ]

iteration_scheme ::=
while condition
| for loop_parameter_specification

label ::= identifier

letter ::= upper_case_letter | lower_case_letter

letter_or_digit ::= letter | digit

library_clause ::= library logical_name_list ;

library_unit ::=
primary_unit
| secondary_unit

literal ::=
numeric_literal
| enumeration_literal
| string_literal
| bit_string_literal
| null

logical_name
::= identifier

logical_name_list ::= logical_name { , logical_name }

logical_operator ::= and | or | nand | nor | xor | xnor

loop_statement
::=
[ loop_label : ]
[ iteration_scheme ] loop
sequence_of_statements
end loop [ loop_label ] ;

miscellaneous_operator ::= ** | abs | not

mode
::= in | out | inout | buffer | linkage

multiplying_operator
::= * | / | mod | rem

name
::=
simple_name
| operator_symbol
| selected_name
| indexed_name
| slice_name
| attribute_name

next_statement ::=
[ label : ] next [ loop_label ] [ when condition ] ;

null_statement ::= [ label : ] null ;

numeric_literal ::=
abstract_literal
| physical_literal

object_declaration ::=
constant_declaration
| signal_declaration
| variable_declaration
| file_declaration

operator_symbol ::= string_literal

options ::= [ guarded ] [ delay_mechanism ]

package_body ::=
package body package_simple_name is
package_body_declarative_part
end [ package body ] [ package_simple_name ] ;

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

package_body_declarative_part ::=
{ package_body_declarative_item }

package_declaration ::=
package identifier is
package_declarative_part
end [ package ] [ package_simple_name ] ;

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

package_declarative_part ::=
{ package_declarative_item }

parameter_specification ::=
identifier in discrete_range

physical_literal ::= [ abstract_literal ] unit_name

physical_type_definition ::=
range_constraint
units
base_unit_declaration
{ secondary_unit_declaration }
end units [ physical_type_simple_name ]

port_clause ::=
port ( port_list ) ;

port_list ::= port_interface_list

port_map_aspect ::=
port map ( port_association_list )

prefix ::=
name
| function_call

primary ::=
name
| literal
| aggregate
| function_call
| qualified_expression
| type_conversion
| allocator
| ( expression )

primary_unit ::=
entity_declaration
| configuration_declaration
| package_declaration

procedure_call ::= procedure_name [ ( actual_parameter_part ) ]

procedure_call_statement ::=
[ label : ] procedure_call ;

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

process_declarative_part ::=
{ process_declarative_item }

process_statement ::=
[ process_label : ]
[ postponed ] process [ ( sensitivity_list ) ] [ is ]
process_declarative_part
begin
process_statement_part
end [ postponed ] process [ process_label ] ;

process_statement_part ::=
{ sequential_statement }

qualified_expression ::=
type_mark ' ( expression )
| type_mark ' aggregate

range ::=
range_attribute_name
| simple_expression direction simple_expression

range_constraint ::= range range

record_type_definition
::=
record
element_declaration
{ element_declaration }
end record [ record_type_simple_name ]

relation ::=
shift_expression [ relational_operator shift_expression ]

relational_operator ::= = | /= | < | <= | > | >=

report_statement ::=
[ label : ]
report expression
[ severity expression ] ;

return_statement ::=
[ label : ] return [ expression ] ;

scalar_type_definition ::=
enumeration_type_definition | integer_type_definition
| floating_type_definition | physical_type_definition

secondary_unit ::=
architecture_body
| package_body

secondary_unit_declaration ::= identifier = physical_literal ;

selected_name ::= prefix . suffix

selected_signal_assignment ::=
with expression select
target <= options selected_waveforms ;

selected_waveforms ::=
{ waveform when choices , }
waveform when choices

sensitivity_clause ::= on sensitivity_list

sensitivity_list ::= signal_name { , signal_name }

sequence_of_statements ::=
{ sequential_statement }

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

shift_expression ::=
simple_expression [ shift_operator simple_expression ]

shift_operator ::= sll | srl | sla | sra | rol | ror

sign
::= + | -

signal_assignment_statement ::=
[ label : ] target <= [ delay_mechanism ] waveform ;

signal_declaration ::=
signal identifier_list : subtype_indication [ signal_kind ] [ := expression ] ;

signal_kind ::= register | bus

signal_list
::=
signal_name { , signal_name }
| others
| all

signature
::= [ [ type_mark { , type_mark } ] [ return type_mark ] ]

simple_expression ::=
[ sign ] term { adding_operator term }

simple_name ::= identifier

slice_name ::= prefix ( discrete_range )

string_literal ::= " { graphic_character } "

subprogram_body ::=
subprogram_specification is
subprogram_declarative_part
begin
subprogram_statement_part
end [ subprogram_kind ] [ designator ] ;

subprogram_declaration ::=
subprogram_specification ;

subprogram_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

subprogram_declarative_part ::=
{ subprogram_declarative_item }

subprogram_kind ::= procedure | function

subprogram_specification
::=
procedure designator [ ( formal_parameter_list ) ]
| [ pure | impure ] function designator [ ( formal_parameter_list ) ]
return type_mark

subprogram_statement_part ::=
{ sequential_statement }

subtype_declaration ::=
subtype identifier is subtype_indication ;

subtype_indication ::=
[ resolution_function_name ] type_mark [ constraint ]

suffix ::=
simple_name
| character_literal
| operator_symbol
| all

target
::=
name
| aggregate

term ::=
factor { multiplying_operator factor }

timeout_clause ::= for time_expression

type_conversion ::= type_mark ( expression )

type_declaration ::=
full_type_declaration
| incomplete_type_declaration

type_definition ::=
scalar_type_definition
| composite_type_definition
| access_type_definition
| file_type_definition

type_mark ::=
type_name
| subtype_name

unconstrained_array_definition ::=
array ( index_subtype_definition { , index_subtype_definition } )
of element_subtype_indication

use_clause ::=
use selected_name { , selected_name } ;

variable_assignment_statement ::=
[ label : ] target := expression ;

variable_declaration::=
[ shared ] variable identifier_list : subtype_indication [ := expression ] ;

wait_statement ::=
[ label : ] wait [ sensitivity_clause ] [ condition_clause ] [ timeout_clause ] ;

waveform ::=
waveform_element { , waveform_element }
| unaffected

waveform_element ::=
value_expression [ after time_expression ]
| null [ after time_expression ]