(Normative)

The formal syntax of SystemVerilog is described using Backus-Naur Form (BNF). The conventions used are:

• Keywords and punctuation are in bold text.
• Syntactic categories are named in non-bold text.
• A vertical bar ( | ) separates alternatives.
• Square brackets ( [ ] ) enclose optional items.
• Braces ( { } ) enclose items which can be repeated zero or more times.

The full syntax and semantics of Verilog and SystemVerilog are not described solely using BNF. The normative text description contained within the chapters of the IEEE 1364-2001 Verilog standard and this SystemVerilog document provide additional details on the syntax and semantics described in this BNF.

Source text

Library source text

library_text ::= { library_descriptions }

library_descriptions ::=
library_declaration
| include_statement
| config_declaration
| ;

library_declaration ::=
library library_identifier file_path_spec { , file_path_spec }
[ -incdir file_path_spec { , file_path_spec } ] ;

file_path_spec ::= file_path

include_statement ::= include file_path_spec ;

Configuration source text

config_declaration ::=
config config_identifier ;
design_statement
{ config_rule_statement }
endconfig [ : config_identifier ]

design_statement ::= design { [ library_identifier . ] cell_identifier } ;

config_rule_statement ::=
default_clause liblist_clause
| inst_clause liblist_clause
| inst_clause use_clause
| cell_clause liblist_clause
| cell_clause use_clause
| ;

default_clause ::= default

inst_clause ::= instance inst_name

inst_name ::= topmodule_identifier { . instance_identifier }

cell_clause ::= cell [ library_identifier . ] cell_identifier

liblist_clause ::= liblist {library_identifier}

use_clause ::= use [ library_identifier . ] cell_identifier [ : config ]

Module and primitive source text

source_text ::= [ timeunits_declaration ] { description }

description ::=
module_declaration
| udp_declaration
| interface_declaration
| program_declaration
| package_declaration
| { attribute_instance } package_item
| { attribute_instance } bind_directive

module_nonansi_header ::=
{ attribute_instance } module_keyword [ lifetime ] module_identifier [ parameter_port_list ]
list_of_ports ;

module_ansi_header ::=
{ attribute_instance } module_keyword [ lifetime ] module_identifier [ parameter_port_list ]
[ list_of_port_declarations ] ;

module_declaration ::=
module_nonansi_header [ timeunits_declaration ] { module_item }
endmodule [ : module_identifier ]
| module_ansi_header [ timeunits_declaration ] { non_port_module_item }
endmodule [ : module_identifier ]
| { attribute_instance } module_keyword [ lifetime ] module_identifier ( .* ) ;
[ timeunits_declaration ] { module_item } endmodule [ : module_identifier ]
| extern module_nonansi_header
| extern module_ansi_header

module_keyword ::= module | macromodule

interface_nonansi_header ::=
{ attribute_instance } interface [ lifetime ] interface_identifier
[ parameter_port_list ] list_of_ports ;

interface_ansi_header ::=
{attribute_instance } interface [ lifetime ] interface_identifier
[ parameter_port_list ] [ list_of_port_declarations ] ;

interface_declaration ::=
interface_nonansi_header [ timeunits_declaration ] { interface_item }
endinterface [ : interface_identifier ]
| interface_ansi_header [ timeunits_declaration ] { non_port_interface_item }
endinterface [ : interface_identifier ]
| { attribute_instance } interface interface_identifier ( .* ) ;
[ timeunits_declaration ] { interface_item }
endinterface [ : interface_identifier ]
| extern interface_nonansi_header
| extern interface_ansi_header

program_nonansi_header ::=
{ attribute_instance } program [ lifetime ] program_identifier
[ parameter_port_list ] list_of_ports ;

program_ansi_header ::=
{attribute_instance } program [ lifetime ] program_identifier
[ parameter_port_list ] [ list_of_port_declarations ] ;

program_declaration ::=
program_nonansi_header [ timeunits_declaration ] { program_item }
endprogram [ : program_identifier ]
| program_ansi_header [ timeunits_declaration ] { non_port_program_item }
endprogram [ : program_identifier ]
| { attribute_instance } program program_identifier ( .* ) ;
[ timeunits_declaration ] { program_item }
endprogram [ : program_identifier ]
| extern program_nonansi_header
| extern program_ansi_header

class_declaration ::=
[ virtual ] class [ lifetime ] class_identifier [ parameter_port_list ]
[ extends class_type [ ( list_of_arguments ) ] ] ;
{ class_item }
endclass [ : class_identifier]

package_declaration ::=
{ attribute_instance } package package_identifier ;
[ timeunits_declaration ] { { attribute_instance } package_item }
endpackage [ : package_identifier ]

timeunits_declaration ::=
timeunit time_literal ;
| timeprecision time_literal ;
| timeunit time_literal ;
timeprecision time_literal ;
| timeprecision time_literal ;
timeunit time_literal ;

Module parameters and ports

parameter_port_list ::=
# ( list_of_param_assignments { , parameter_port_declaration } )
| # ( parameter_port_declaration { , parameter_port_declaration } )

parameter_port_declaration ::=
parameter_declaration
| data_type list_of_param_assignments
| type list_of_type_assignments

list_of_ports ::= ( port { , port } )

list_of_port_declarations ::=
( [ { attribute_instance} ansi_port_declaration { , { attribute_instance} ansi_port_declaration } ] )

port_declaration ::=
{ attribute_instance } inout_declaration
| { attribute_instance } input_declaration
| { attribute_instance } output_declaration
| { attribute_instance } ref_declaration
| { attribute_instance } interface_port_declaration

port ::=
[ port_expression ]
| . port_identifier ( [ port_expression ] )

port_expression ::=
port_reference
| { port_reference { , port_reference } }

port_reference ::=
port_identifier constant_select

port_direction ::= input | output | inout | ref

net_port_header ::= [ port_direction ] port_type

variable_port_header ::= [ port_direction ] data_type

interface_port_header ::=
interface_identifier [ . modport_identifier ]
| interface [ . modport_identifier ]

ansi_port_declaration ::=
[ net_port_header | interface_port_header ] port_identifier { unpacked_dimension }
| [ variable_port_header ] port_identifier variable_dimension [ = constant_expression ]
| [ net_port_header | variable_port_header ] . port_identifier ( [ expression ] )

Module items

module_common_item ::=
module_or_generate_item_declaration
| interface_instantiation
| program_instantiation
| concurrent_assertion_item
| bind_directive
| continuous_assign
| net_alias
| initial_construct
| final_construct
| always_construct

module_item ::=
port_declaration ;
| non_port_module_item

module_or_generate_item ::=
{ attribute_instance } parameter_override
| { attribute_instance } gate_instantiation
| { attribute_instance } udp_instantiation
| { attribute_instance } module_instantiation
| { attribute_instance } module_common_item

module_or_generate_item_declaration ::=
package_or_generate_item_declaration
| genvar_declaration
| clocking_declaration
| default clocking clocking_identifier ;

non_port_module_item ::=
generated_module_instantiation
| module_or_generate_item
| specify_block
| { attribute_instance } specparam_declaration
| program_declaration
| module_declaration
| timeunits_declaration

parameter_override ::= defparam list_of_defparam_assignments ;

bind_directive ::= bind hierarchical_identifier constant_select bind_instantiation ;

bind_instantiation ::=
program_instantiation
| module_instantiation
| interface_instantiation

Interface items

interface_or_generate_item ::=
{ attribute_instance } module_common_item
| { attribute_instance } modport_declaration
| { attribute_instance } extern_tf_declaration

extern_tf_declaration ::=
extern method_prototype ;
| extern forkjoin task_prototype ;

interface_item ::=
port_declaration ;
| non_port_interface_item

non_port_interface_item ::=
generated_interface_instantiation
| { attribute_instance } specparam_declaration
| interface_or_generate_item
| program_declaration
| interface_declaration
| timeunits_declaration

Program items

program_item ::=
port_declaration ;
| non_port_program_item

non_port_program_item ::=
{ attribute_instance } continuous_assign
| { attribute_instance } module_or_generate_item_declaration
| { attribute_instance } specparam_declaration
| { attribute_instance } initial_construct
| { attribute_instance } concurrent_assertion_item
| { attribute_instance } timeunits_declaration

Class items

class_item ::=
{ attribute_instance } class_property
| { attribute_instance } class_method
| { attribute_instance } class_constraint
| { attribute_instance } type_declaration
| { attribute_instance } class_declaration
| { attribute_instance } timeunits_declaration
| ;

class_property ::=
{ property_qualifier } data_declaration
| const { class_item_qualifier } data_type const_identifier [ = constant_expression ] ;

class_method ::=
{ method_qualifier } task_declaration
| { method_qualifier } function_declaration
| extern { method_qualifier } method_prototype ;
| { method_qualifier } class_constructor_declaration
| extern { method_qualifier } class_constructor_prototype

class_constructor_prototype ::=
function new ( [ tf_port_list ] ) ;

class_constraint ::=
constraint_prototype
| constraint_declaration

class_item_qualifier ::=
static
| protected
| local

property_qualifier ::=
rand
| randc
| class_item_qualifier

method_qualifier ::=
virtual
| class_item_qualifier

method_prototype ::=
task_prototype ;
| function_prototype ;

class_constructor_declaration ::=
function [ class_scope ] new [ ( [ tf_port_list ] ) ] ;
{ block_item_declaration }
[ super . new [ ( list_of_arguments ) ] ; ]
{ function_statement_or_null }
endfunction [ : new ]

Constraints

constraint_declaration ::= [ static ] constraint constraint_identifier constraint_block

constraint_block ::= { { constraint_block_item } }

constraint_block_item ::=
solve identifier_list before identifier_list ;
| constraint_expression

constraint_expression ::=
expression_or_dist ;
| expression -> constraint_set
| if ( expression ) constraint_set [ else constraint_set ]
| foreach ( array_identifier [ loop_variables ] ) constraint_set

constraint_set ::=
constraint_expression
| { { constraint_expression } }

dist_list ::= dist_item { , dist_item }

dist_item ::= value_range [ dist_weight ]

dist_weight ::=
:= expression
| :/ expression

constraint_prototype ::= [ static ] constraint constraint_identifier ;

extern_constraint_declaration ::=
[ static ] constraint class_scope constraint_identifier constraint_block

identifier_list ::= identifier { , identifier }

Package items

package_item ::=
package_or_generate_item_declaration
| specparam_declaration
| anonymous_program
| timeunits_declaration

package_or_generate_item_declaration ::=
net_declaration
| data_declaration
| task_declaration
| function_declaration
| dpi_import_export
| extern_constraint_declaration
| class_declaration
| class_constructor_declaration
| parameter_declaration ;
| local_parameter_declaration
| covergroup_declaration
| overload_declaration
| concurrent_assertion_item_declaration
| ;

anonymous_program ::= program ; { anonymous_program_item } endprogram

anonymous_program_item ::=
task_declaration
| function_declaration
| class_declaration
| covergroup_declaration
| class_constructor_declaration
| ;

Declarations

Declaration types

Declaration data types

Declaration lists

list_of_defparam_assignments ::= defparam_assignment { , defparam_assignment }

list_of_genvar_identifiers ::= genvar_identifier { , genvar_identifier }

list_of_interface_identifiers ::= interface_identifier { unpacked_dimension }
{ , interface_identifier { unpacked_dimension } }

list_of_net_decl_assignments ::= net_decl_assignment { , net_decl_assignment }

list_of_param_assignments ::= param_assignment { , param_assignment }

list_of_port_identifiers ::= port_identifier { unpacked_dimension }
{ , port_identifier { unpacked_dimension } }

list_of_udp_port_identifiers ::= port_identifier { , port_identifier }

list_of_specparam_assignments ::= specparam_assignment { , specparam_assignment }

list_of_tf_variable_identifiers ::= port_identifier variable_dimension [ = expression ]
{ , port_identifier variable_dimension [ = expression ] }

list_of_type_assignments ::= type_assignment { , type_assignment }

list_of_variable_decl_assignments ::= variable_decl_assignment { , variable_decl_assignment }

list_of_variable_identifiers ::= variable_identifier variable_dimension
{ , variable_identifier variable_dimension }

list_of_variable_port_identifiers ::= port_identifier variable_dimension [ = constant_expression ]
{ , port_identifier variable_dimension [ = constant_expression ] }

list_of_virtual_interface_decl ::=
variable_identifier [ = interface_instance_identifier ]
{ , variable_identifier [ = interface_instance_identifier ] }

Declaration assignments

defparam_assignment ::= hierarchical_parameter_identifier = constant_mintypmax_expression

net_decl_assignment ::= net_identifier { unpacked_dimension } [ = expression ]

param_assignment ::= parameter_identifier { unpacked_dimension } = constant_param_expression

specparam_assignment ::=
specparam_identifier = constant_mintypmax_expression
| pulse_control_specparam

type_assignment ::= type_identifier = data_type

pulse_control_specparam ::=
PATHPULSE$ = ( reject_limit_value [ , error_limit_value ] ) ;
| PATHPULSE$ specify_input_terminal_descriptor $ specify_output_terminal_descriptor
= ( reject_limit_value [ , error_limit_value ] ) ;

error_limit_value ::= limit_value

reject_limit_value ::= limit_value

limit_value ::= constant_mintypmax_expression

variable_decl_assignment ::=
variable_identifier variable_dimension [ = expression ]
| dynamic_array_variable_identifier [ ] [ = dynamic_array_new ]
| class_variable_identifier [ = class_new ]
| [ covergroup_variable_identifier ] = new [ ( list_of_arguments ) ]

class_new ::= new [ ( list_of_arguments ) | expression ]

dynamic_array_new ::= new [ expression ] [ ( expression ) ]

Declaration ranges

unpacked_dimension ::= [ constant_range ]
| [ constant_expression ]

packed_dimension ::=
[ constant_range ]
| unsized_dimension

associative_dimension ::=
[ data_type ]
| [ * ]

variable_dimension ::=
{ sized_or_unsized_dimension }
| associative_dimension
| queue_dimension

queue_dimension ::= [ $ [ : constant_expression ] ]

unsized_dimension ::= [ ]

sized_or_unsized_dimension ::= unpacked_dimension | unsized_dimension

Function declarations

function_data_type ::= data_type | void

function_data_type_or_implicit ::=
function_data_type
| [ signing ] { packed_dimension }

function_declaration ::= function [ lifetime ] function_body_declaration

function_body_declaration ::=
function_data_type_or_implicit
[ interface_identifier . | class_scope ] function_identifier ;
{ tf_item_declaration }
{ function_statement_or_null }
endfunction [ : function_identifier ]
| function_data_type_or_implicit
[ interface_identifier . | class_scope ] function_identifier ( [ tf_port_list ] ) ;
{ block_item_declaration }
{ function_statement_or_null }
endfunction [ : function_identifier ]

function_prototype ::= function function_data_type function_identifier ( [ tf_port_list ] )

dpi_import_export ::=
import "DPI" [ dpi_function_import_property ] [ c_identifier = ] dpi_function_proto ;
| import "DPI" [ dpi_task_import_property ] [ c_identifier = ] dpi_task_proto ;
| export "DPI" [ c_identifier = ] function function_identifier ;
| export "DPI" [ c_identifier = ] task task_identifier ;

dpi_function_import_property ::= context | pure

dpi_task_import_property ::= context

dpi_function_proto ::= function_prototype

dpi_task_proto ::= task_prototype

Task declarations

task_declaration ::= task [ lifetime ] task_body_declaration

task_body_declaration ::=
[ interface_identifier . | class_scope ] task_identifier ;
{ tf_item_declaration }
{ statement_or_null }
endtask [ : task_identifier ]
| [ interface_identifier . | class_scope ] task_identifier ( [ tf_port_list ] ) ;
{ block_item_declaration }
{ statement_or_null }
endtask [ : task_identifier ]

tf_item_declaration ::=
block_item_declaration
| tf_port_declaration

tf_port_list ::=
tf_port_item { , tf_port_item }

tf_port_item ::=
{ attribute_instance }
[ tf_port_direction ] data_type_or_implicit
port_identifier variable_dimension [ = expression ]

tf_port_direction ::= port_direction | const ref

tf_port_declaration ::=
{ attribute_instance } tf_port_direction data_type_or_implicit list_of_tf_variable_identifiers ;

task_prototype ::= task task_identifier ( [ tf_port_list ] )

Block item declarations

block_item_declaration ::=
{ attribute_instance } data_declaration
| { attribute_instance } local_parameter_declaration
| { attribute_instance } parameter_declaration ;
| { attribute_instance } overload_declaration

overload_declaration ::=
bind overload_operator function data_type function_identifier ( overload_proto_formals ) ;

overload_operator ::= + | ++ | - | - - | * | ** | / | % | == | != | < | <= | > | >= | =

overload_proto_formals ::= data_type { , data_type}

Interface declarations

virtual_interface_declaration ::=
virtual [ interface ] interface_identifier list_of_virtual_interface_decl ;

modport_declaration ::= modport modport_item { , modport_item } ;

modport_item ::= modport_identifier ( modport_ports_declaration { , modport_ports_declaration } )

modport_ports_declaration ::=
{ attribute_instance } modport_simple_ports_declaration
| { attribute_instance } modport_hierarchical_ports_declaration
| { attribute_instance } modport_tf_ports_declaration
| { attribute_instance } modport_clocking_declaration

modport_clocking_declaration ::= clocking clocking_identifier

modport_simple_ports_declaration ::=
port_direction modport_simple_port { , modport_simple_port }

modport_simple_port ::=
port_identifier
| . port_identifier ( [ expression ] )

modport_hierarchical_ports_declaration ::=
interface_instance_identifier [ [ constant_expression ] ] . modport_identifier

modport_tf_ports_declaration ::=
import_export modport_tf_port { , modport_tf_port }

modport_tf_port ::=
method_prototype
| tf_identifier

import_export ::= import | export

Assertion declarations

concurrent_assertion_item ::= [ block_identifier : ] concurrent_assertion_statement
concurrent_assertion_statement ::=
assert_property_statement
| assume_property_statement
| cover_property_statement

assert_property_statement::=
assert property ( property_spec ) action_block

assume_property_statement::=
assume property ( property_spec ) ;

cover_property_statement::=
cover property ( property_spec ) statement_or_null

expect_property_statement ::=
expect ( property_spec ) action_block

property_instance ::=
ps_property_identifier [ ( [ actual_arg_list ] ) ]

concurrent_assertion_item_declaration ::=
property_declaration
| sequence_declaration

property_declaration ::=
property property_identifier [ ( [ list_of_formals ] ) ] ;
{ assertion_variable_declaration }
property_spec ;
endproperty [ : property_identifier ]

property_spec ::=
[clocking_event ] [ disable iff ( expression_or_dist ) ] property_expr

property_expr ::=
sequence_expr
| ( property_expr )
| not property_expr
| property_expr or property_expr
| property_expr and property_expr
| sequence_expr |-> property_expr
| sequence_expr |=> property_expr
| if ( expression_or_dist ) property_expr [ else property_expr ]
| property_instance
| clocking_event property_expr

sequence_declaration ::=
sequence sequence_identifier [ ( [ list_of_formals ] ) ] ;
{ assertion_variable_declaration }
sequence_expr ;
endsequence [ : sequence_identifier ]

sequence_expr ::=
cycle_delay_range sequence_expr { cycle_delay_range sequence_expr }
| sequence_expr cycle_delay_range sequence_expr { cycle_delay_range sequence_expr }
| expression_or_dist [ boolean_abbrev ]
| ( expression_or_dist { , sequence_match_item } ) [ boolean_abbrev ]
| sequence_instance [ sequence_abbrev ]
| ( sequence_expr { , sequence_match_item } ) [ sequence_abbrev ]
| sequence_expr and sequence_expr
| sequence_expr intersect sequence_expr
| sequence_expr or sequence_expr
| first_match ( sequence_expr { , sequence_match_item} )
| expression_or_dist throughout sequence_expr
| sequence_expr within sequence_expr
| clocking_event sequence_expr

cycle_delay_range ::=
## integral_number
| ## identifier
| ## ( constant_expression )
| ## [ cycle_delay_const_range_expression ]

sequence_method_call ::=
sequence_instance . method_identifier

sequence_match_item ::=
operator_assignment
| inc_or_dec_expression
| subroutine_call

sequence_instance ::=
ps_sequence_identifier [ ( [ actual_arg_list ] ) ]

formal_list_item ::=
formal_identifier [ = actual_arg_expr ]

list_of_formals ::= formal_list_item { , formal_list_item }

actual_arg_list ::=
actual_arg_expr { , actual_arg_expr }
| . formal_identifier ( actual_arg_expr ) { , . formal_identifier ( actual_arg_expr ) }

actual_arg_expr ::=
event_expression
| $

boolean_abbrev ::=
consecutive_repetition
| non_consecutive_repetition
| goto_repetition

sequence_abbrev ::= consecutive_repetition

consecutive_repetition ::= [* const_or_range_expression ]

non_consecutive_repetition ::= [= const_or_range_expression ]

goto_repetition ::= [-> const_or_range_expression ]

const_or_range_expression ::=
constant_expression
| cycle_delay_const_range_expression

cycle_delay_const_range_expression ::=
constant_expression : constant_expression
| constant_expression : $

expression_or_dist ::= expression [ dist { dist_list } ]

assertion_variable_declaration ::=
data_type list_of_variable_identifiers ;

Covergroup declarations

covergroup_declaration ::=
covergroup covergroup_identifier [ ( [ tf_port_list ] ) ] [ coverage_event ] ;
{ coverage_spec_or_option ; }
endgroup [ : covergroup_identifier ]

coverage_spec_or_option ::=
{attribute_instance} coverage_spec
| {attribute_instance} coverage_option ;

coverage_option ::=
option. member_identifier = expression
| type_option. member_identifier = expression

coverage_spec ::=
cover_point
| cover_cross

coverage_event ::=
clocking_event
| @@( block_event_expression )

block_event_expression ::=
block_event_expression or block_event_expression
| begin hierarchical_btf_identifier
| end hierarchical_btf_identifier

hierarchical_btf_identifier ::=
hierarchical_tf_identifier
| hierarchical_block_identifier
| hierarchical_identifier [ class_scope ] method_identifier

cover_point ::= [ cover_point_identifier : ] coverpoint expression [ iff ( expression ) ] bins_or_empty

bins_or_empty ::=
{ {attribute_instance} { bins_or_options ; } }
| ;

bins_or_options ::=
coverage_option
| [ wildcard ] bins_keyword bin_identifier [ [ [ expression ] ] ] = { range_list } [ iff ( expression ) ]
| [ wildcard ] bins_keyword bin_identifier [ [ ] ] = trans_list [ iff ( expression ) ]
| bins_keyword bin_identifier [ [ [ expression ] ] ] = default [ iff ( expression ) ]
| bins_keyword bin_identifier = default sequence [ iff ( expression ) ]

bins_keyword::= bins | illegal_bins | ignore_bins

range_list ::= value_range { , value_range }

trans_list ::= ( trans_set ) { , ( trans_set ) }

trans_set ::= trans_range_list => trans_range_list { => trans_range_list }

trans_range_list ::=
trans_item
| trans_item [ [* repeat_range ] ]
| trans_item [ [-> repeat_range ] ]
| trans_item [ [= repeat_range ] ]

trans_item ::= range_list

repeat_range ::=
expression
| expression : expression

cover_cross ::= [ cover_point_identifier : ] cross list_of_coverpoints [ iff ( expression ) ] select_bins_or_empty

list_of_coverpoints ::= cross_item , cross_item { , cross_item }

cross_item ::=
cover_point_identifier
| variable_identifier

select_bins_or_empty ::=
{ { bins_selection_or_option ; } }
| ;

bins_selection_or_option ::=
{ attribute_instance } coverage_option
| { attribute_instance } bins_selection

bins_selection ::= bins_keyword bin_identifier = select_expression [ iff ( expression ) ]

select_expression ::=
select_condition
| ! select_condition
| select_expression && select_expression
| select_expression || select_expression
| ( select_expression )

select_condition ::= binsof ( bins_expression ) [ intersect { open_range_list } ]

bins_expression ::=
variable_identifier
| cover_point_identifier [ . bins_identifier ]

open_range_list ::= open_value_range { , open_value_range }

open_value_range ::= value_range

Primi