SystemVerilog IEEE 1800-2012 BNF

library_text ::=
 { library_description }
library_description ::=
 library_declaration | include_statement | config_declaration | ;
library_declaration ::=
 library library_identifier file_path_spec { , file_path_spec }
 [ -incdir file_path_spec { , file_path_spec } ] ;
include_statement ::=
 include file_path_spec ;

source_text ::=
 [ timeunits_declaration ] { description }
description ::=
 module_declaration
 | udp_declaration
 | interface_declaration
 | program_declaration
 | package_declaration
 | { attribute_instance } package_item
 | { attribute_instance } bind_directive
 | config_declaration
module_nonansi_header ::=
 { attribute_instance } module_keyword [ lifetime ] module_identifier
 { package_import_declaration } [ parameter_port_list ] list_of_ports ;
module_ansi_header ::=
 { attribute_instance } module_keyword [ lifetime ] module_identifier
 { package_import_declaration } [ 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_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
interface_nonansi_header ::=
 { attribute_instance } interface [ lifetime ] interface_identifier
 { package_import_declaration } [ parameter_port_list ] list_of_ports ;
interface_ansi_header ::=
 { attribute_instance } interface [ lifetime ] interface_identifier
 { package_import_declaration } [ 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
program_nonansi_header ::=
 { attribute_instance } program [ lifetime ] program_identifier { package_import_declaration }
 [ parameter_port_list ] list_of_ports ;
program_ansi_header ::=
 { attribute_instance } program [ lifetime ] program_identifier { package_import_declaration }
 [ parameter_port_list ] [ list_of_port_declarations ] ;
checker_declaration ::=
 checker checker_identifier [ ( [ checker_port_list ] ) ] ;
 { { attribute_instance } checker_or_generate_item } endchecker [ : checker_identifier ]
class_declaration ::=
 [ virtual ] class [ lifetime ] class_identifier [ parameter_port_list ]
 [ extends class_type [ ( list_of_arguments ) ] ]
 [ implements interface_class_type { , interface_class_type } ] ; { class_item } endclass
 [ : class_identifier ]
interface_class_type ::=
 ps_class_identifier [ parameter_value_assignment ]
interface_class_declaration ::=
 interface class class_identifier [ parameter_port_list ]
 [ extends interface_class_type { , interface_class_type } ] ; { interface_class_item }
 endclass [ : class_identifier ]
interface_class_item ::=
 type_declaration
 | { attribute_instance } interface_class_method
 | local_parameter_declaration ;
 | parameter_declaration ;
 | ;
interface_class_method ::=
 pure virtual method_prototype ;
package_declaration ::=
 { attribute_instance } package [ lifetime ] package_identifier ; [ timeunits_declaration ]
 { { attribute_instance } package_item } endpackage [ : package_identifier ]
timeunits_declaration ::=
 timeunit time_literal [ / time_literal ] ;
 | timeprecision time_literal ;
 | timeunit time_literal ; timeprecision time_literal ;
 | timeprecision time_literal ; timeunit time_literal ;

parameter_port_list ::=
 # ( list_of_param_assignments { , parameter_port_declaration } )
 | # ( parameter_port_declaration { , parameter_port_declaration } )
 | # ( )
parameter_port_declaration ::=
 parameter_declaration
 | local_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 ] net_port_type
variable_port_header ::=
 [ port_direction ] variable_port_type
interface_port_header ::=
 interface_identifier [ . modport_identifier ] | interface [ . modport_identifier ]
ansi_port_declaration ::=
 [ net_port_header | interface_port_header ] port_identifier { unpacked_dimension }
 [ = constant_expression ]
 | [ variable_port_header ] port_identifier { variable_dimension } [ = constant_expression ]
 | [ port_direction ] . port_identifier ( [ expression ] )

elaboration_system_task ::=
 $fatal [ ( finish_number [ , list_of_arguments ] ) ] ;
 | $error [ ( [ list_of_arguments ] ) ] ;
 | $warning [ ( [ list_of_arguments ] ) ] ;
 | $info [ ( [ list_of_arguments ] ) ] ;
finish_number ::=
 0 | 1 | 2
module_common_item ::=
 module_or_generate_item_declaration
 | interface_instantiation
 | program_instantiation
 | assertion_item
 | bind_directive
 | continuous_assign
 | net_alias
 | initial_construct
 | final_construct
 | always_construct
 | loop_generate_construct
 | conditional_generate_construct
 | elaboration_system_task
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 ;
 | default disable iff expression_or_dist ;
non_port_module_item ::=
 generate_region
 | module_or_generate_item
 | specify_block
 | { attribute_instance } specparam_declaration
 | program_declaration
 | module_declaration
 | interface_declaration
 | timeunits_declaration
parameter_override ::=
 defparam list_of_defparam_assignments ;
bind_directive ::=
 bind bind_target_scope [ : bind_target_instance_list ] bind_instantiation ;
 | bind bind_target_instance bind_instantiation ;
bind_target_scope ::=
 module_identifier | interface_identifier
bind_target_instance ::=
 hierarchical_identifier constant_bit_select
bind_target_instance_list ::=
 bind_target_instance { , bind_target_instance }
bind_instantiation ::=
 program_instantiation | module_instantiation | interface_instantiation | checker_instantiation 

config_declaration ::=
 config config_identifier ; { local_parameter_declaration ; } 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 ]
 | use named_parameter_assignment { , named_parameter_assignment } [ : config ]
 | use [ library_identifier . ] cell_identifier named_parameter_assignment
 { , named_parameter_assignment } [ : config ]

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 ::=
 generate_region
 | interface_or_generate_item
 | program_declaration
 | interface_declaration
 | timeunits_declaration 

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 } initial_construct
 | { attribute_instance } final_construct
 | { attribute_instance } concurrent_assertion_item
 | timeunits_declaration
 | program_generate_item
program_generate_item ::=
 loop_generate_construct
 | conditional_generate_construct
 | generate_region
 | elaboration_system_task 

checker_port_list ::=
 checker_port_item { , checker_port_item }
checker_port_item ::=
 { attribute_instance } [ checker_port_direction ] property_formal_type formal_port_identifier
 { variable_dimension } [ = property_actual_arg ]
checker_port_direction ::=
 input | output
checker_or_generate_item ::=
 checker_or_generate_item_declaration
 | initial_construct
 | always_construct
 | final_construct
 | assertion_item
 | continuous_assign
 | checker_generate_item
checker_or_generate_item_declaration ::=
 [ rand ] data_declaration
 | function_declaration
 | checker_declaration
 | assertion_item_declaration
 | covergroup_declaration
 | overload_declaration
 | genvar_declaration
 | clocking_declaration
 | default clocking clocking_identifier ;
 | default disable iff expression_or_dist ;
 | ;
checker_generate_item ::=
 loop_generate_construct
 | conditional_generate_construct
 | generate_region
 | elaboration_system_task 

class_item ::=
 { attribute_instance } class_property
 | { attribute_instance } class_method
 | { attribute_instance } class_constraint
 | { attribute_instance } class_declaration
 | { attribute_instance } covergroup_declaration
 | local_parameter_declaration ;
 | parameter_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
 | pure virtual { class_item_qualifier } method_prototype ;
 | 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 ::=
 random_qualifier | class_item_qualifier
random_qualifier ::=
 rand | randc
method_qualifier ::=
 [ pure ] 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 ]

constraint_declaration ::=
 [ static ] constraint constraint_identifier constraint_block
constraint_block ::=
 { { constraint_block_item } }
constraint_block_item ::=
 solve solve_before_list before solve_before_list ; | constraint_expression
solve_before_list ::=
 constraint_primary { , constraint_primary }
constraint_primary ::=
 [ implicit_class_handle . | class_scope ] hierarchical_identifier select
constraint_expression ::=
 [ soft ] expression_or_dist ;
 | uniqueness_constraint ;
 | expression -> constraint_set
 | if ( expression ) constraint_set [ else constraint_set ]
 | foreach ( ps_or_hierarchical_array_identifier [ loop_variables ] ) constraint_set
 | disable soft constraint_primary ;
uniqueness_constraint ::=
 unique { open_range_list }
constraint_set ::=
 constraint_expression | { { constraint_expression } }
dist_list ::=
 dist_item { , dist_item }
dist_item ::=
 value_range [ dist_weight ]
dist_weight ::=
 := expression | :/ expression
constraint_prototype ::=
 [ constraint_prototype_qualifier ] [ static ] constraint constraint_identifier ;
constraint_prototype_qualifier ::=
 extern | pure
extern_constraint_declaration ::=
 [ static ] constraint class_scope constraint_identifier constraint_block
identifier_list ::=
 identifier { , identifier }

package_item ::=
 package_or_generate_item_declaration
 | anonymous_program
 | package_export_declaration
 | timeunits_declaration
package_or_generate_item_declaration ::=
 net_declaration
 | data_declaration
 | task_declaration
 | function_declaration
 | checker_declaration
 | dpi_import_export
 | extern_constraint_declaration
 | class_declaration
 | class_constructor_declaration
 | local_parameter_declaration ;
 | parameter_declaration ;
 | covergroup_declaration
 | overload_declaration
 | assertion_item_declaration
 | ;
anonymous_program ::=
 program ; { anonymous_program_item } endprogram
anonymous_program_item ::=
 task_declaration
 | function_declaration
 | class_declaration
 | covergroup_declaration
 | class_constructor_declaration
 | ;

local_parameter_declaration ::=
 localparam data_type_or_implicit list_of_param_assignments
 | localparam type list_of_type_assignments
parameter_declaration ::=
 parameter data_type_or_implicit list_of_param_assignments
 | parameter type list_of_type_assignments
specparam_declaration ::=
 specparam [ packed_dimension ] list_of_specparam_assignments ;

inout_declaration ::=
 inout net_port_type list_of_port_identifiers
input_declaration ::=
 input net_port_type list_of_port_identifiers
 | input variable_port_type list_of_variable_identifiers
output_declaration ::=
 output net_port_type list_of_port_identifiers
 | output variable_port_type list_of_variable_port_identifiers
interface_port_declaration ::=
 interface_identifier list_of_interface_identifiers
 | interface_identifier . modport_identifier list_of_interface_identifiers
ref_declaration ::=
 ref variable_port_type list_of_variable_identifiers 

data_declaration ::=
 [ const ] [ var ] [ lifetime ] data_type_or_implicit list_of_variable_decl_assignments ;
 | type_declaration
 | package_import_declaration net_type_declaration
package_import_declaration ::=
 import package_import_item { , package_import_item } ;
package_import_item ::=
 package_identifier :: identifier | package_identifier :: *
package_export_declaration ::=
 export *::* ; | export package_import_item { , package_import_item } ;
genvar_declaration ::=
 genvar list_of_genvar_identifiers ;
net_declaration ::=
 net_type [ drive_strength | charge_strength ] [ vectored | scalared ] data_type_or_implicit
 [ delay3 ] list_of_net_decl_assignments ;
 | net_type_identifier [ delay_control ] list_of_net_decl_assignments ;
 | interconnect implicit_data_type [ # delay_value ] net_identifier { unpacked_dimension }
 [ , net_identifier { unpacked_dimension } ] ;
type_declaration ::=
 typedef data_type type_identifier { variable_dimension } ;
 | typedef interface_instance_identifier constant_bit_select . type_identifier type_identifier ;
 | typedef [ enum | struct | union | class | interface class ] type_identifier ;
net_type_declaration ::=
 nettype data_type net_type_identifier [ with [ package_scope | class_scope ] tf_identifier ]
 ;
 | nettype [ package_scope | class_scope ] net_type_identifier net_type_identifier ;
lifetime ::=
 static | automatic

casting_type ::=
 simple_type | constant_primary | signing | string | const
data_type ::=
 integer_vector_type [ signing ] { packed_dimension }
 | integer_atom_type [ signing ]
 | non_integer_type
 | struct_union [ packed [ signing ] ] { struct_union_member { struct_union_member } }
 { packed_dimension }
 | enum [ enum_base_type ] { enum_name_declaration { , enum_name_declaration } }
 { packed_dimension }
 | string
 | chandle
 | virtual [ interface ] interface_identifier [ parameter_value_assignment ]
 [ . modport_identifier ]
 | [ class_scope | package_scope ] type_identifier { packed_dimension }
 | class_type
 | event
 | ps_covergroup_identifier
 | type_reference
data_type_or_implicit ::=
 data_type | implicit_data_type
implicit_data_type ::=
 [ signing ] { packed_dimension }
enum_base_type ::=
 integer_atom_type [ signing ]
 | integer_vector_type [ signing ] [ packed_dimension ]
 | type_identifier [ packed_dimension ]
enum_name_declaration ::=
 enum_identifier [ [ integral_number [ : integral_number ] ] ] [ = constant_expression ]
class_scope ::=
 class_type ::
class_type ::=
 ps_class_identifier [ parameter_value_assignment ]
 { :: class_identifier [ parameter_value_assignment ] }
integer_type ::=
 integer_vector_type | integer_atom_type
integer_atom_type ::=
 byte | shortint | int | longint | integer | time
integer_vector_type ::=
 bit | logic | reg
non_integer_type ::=
 shortreal | real | realtime
net_type ::=
 supply0 | supply1 | tri | triand | trior | trireg | tri0 | tri1 | uwire| wire | wand | wor
net_port_type ::=
 [ net_type ] data_type_or_implicit | net_type_identifier | interconnect implicit_data_type
variable_port_type ::=
 var_data_type
var_data_type ::=
 data_type | var data_type_or_implicit
signing ::=
 signed | unsigned
simple_type ::=
 integer_type | non_integer_type | ps_type_identifier | ps_parameter_identifier
struct_union_member ::=
 { attribute_instance } [ random_qualifier ] data_type_or_void
 list_of_variable_decl_assignments ;
data_type_or_void ::=
 data_type | void
struct_union ::=
 struct | union [ tagged ]
type_reference ::=
 type ( expression ) | type ( data_type )

drive_strength ::=
 ( strength0 , strength1 )
 | ( strength1 , strength0 )
 | ( strength0 , highz1 )
 | ( strength1 , highz0 )
 | ( highz0 , strength1 )
 | ( highz1 , strength0 )
strength0 ::=
 supply0 | strong0 | pull0 | weak0
strength1 ::=
 supply1 | strong1 | pull1 | weak1
charge_strength ::=
 ( small ) | ( medium ) | ( large )

delay3 ::=
 # delay_value
 | # ( mintypmax_expression [ , mintypmax_expression [ , mintypmax_expression ] ] )
delay2 ::=
 # delay_value | # ( mintypmax_expression [ , mintypmax_expression ] )
delay_value ::=
 unsigned_number | real_number | ps_identifier | time_literal | 1step

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 ] }

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 unsized_dimension { variable_dimension }
 [ = dynamic_array_new ]
 | class_variable_identifier [ = class_new ]
class_new ::=
 [ class_scope ] new [ ( list_of_arguments ) ] | new expression
dynamic_array_new ::=
 new [ expression ] [ ( expression ) ]

unpacked_dimension ::=
 [ constant_range ] | [ constant_expression ]
packed_dimension ::=
 [ constant_range ] | unsized_dimension
associative_dimension ::=
 [ data_type ] | [ * ]
variable_dimension ::=
 unsized_dimension | unpacked_dimension | associative_dimension | queue_dimension
queue_dimension ::=
 [ $ [ : constant_expression ] ]
unsized_dimension ::=
 [ ]

function_data_type_or_implicit ::=
 data_type_or_void | implicit_data_type
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 data_type_or_void function_identifier [ ( [ tf_port_list ] ) ]
dpi_import_export ::=
 import dpi_spec_string [ dpi_function_import_property ] [ c_identifier = ] dpi_function_proto
 ;
 | import dpi_spec_string [ dpi_task_import_property ] [ c_identifier = ] dpi_task_proto ;
 | export dpi_spec_string [ c_identifier = ] function function_identifier ;
 | export dpi_spec_string [ c_identifier = ] task task_identifier ;
dpi_spec_string ::=
 "DPI-C" | "DPI"
dpi_function_import_property ::=
 context | pure
dpi_task_import_property ::=
 context
dpi_function_proto ::=
 function_prototype
dpi_task_proto ::=
 task_prototype 

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 ] [ var ] data_type_or_implicit
 [ port_identifier { variable_dimension } [ = expression ] ]
tf_port_direction ::=
 port_direction | const ref
tf_port_declaration ::=
 { attribute_instance } tf_port_direction [ var ] data_type_or_implicit
 list_of_tf_variable_identifiers ;
task_prototype ::=
 task task_identifier [ ( [ tf_port_list ] ) ]

block_item_declaration ::=
 { attribute_instance } data_declaration
 | { attribute_instance } local_parameter_declaration ;
 | { attribute_instance } parameter_declaration ;
 | { attribute_instance } overload_declaration
 | { attribute_instance } let_declaration
overload_declaration ::=
 bind overload_operator function data_type function_identifier ( overload_proto_formals ) ;
overload_operator ::=
 + | ++ | - | -- | * | ** | / | % | == | != | < | <= | > | >= | =
overload_proto_formals ::=
 data_type { , data_type }

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_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_tf_ports_declaration ::=
 import_export modport_tf_port { , modport_tf_port }
modport_tf_port ::=
 method_prototype | tf_identifier
import_export ::=
 import | export

concurrent_assertion_item ::=
 [ block_identifier : ] concurrent_assertion_statement | checker_instantiation
concurrent_assertion_statement ::=
 assert_property_statement
 | assume_property_statement
 | cover_property_statement
 | cover_sequence_statement
 | restrict_property_statement
assert_property_statement ::=
 assert property ( property_spec ) action_block
assume_property_statement ::=
 assume property ( property_spec ) action_block
cover_property_statement ::=
 cover property ( property_spec ) statement_or_null
expect_property_statement ::=
 expect ( property_spec ) action_block
cover_sequence_statement ::=
 cover sequence ( [ clocking_event ] [ disable iff ( expression_or_dist ) ] sequence_expr )
 statement_or_null
restrict_property_statement ::=
 restrict property ( property_spec ) ;
property_instance ::=
 ps_or_hierarchical_property_identifier [ ( [ property_list_of_arguments ] ) ]
property_list_of_arguments ::=
 [ property_actual_arg ] { , [ property_actual_arg ] }
 { , . identifier ( [ property_actual_arg ] ) }
 | . identifier ( [ property_actual_arg ] ) { , . identifier ( [ property_actual_arg ] ) }
property_actual_arg ::=
 property_expr | sequence_actual_arg
assertion_item_declaration ::=
 property_declaration | sequence_declaration | let_declaration
property_declaration ::=
 property property_identifier [ ( [ property_port_list ] ) ] ;
 { assertion_variable_declaration } property_spec [ ; ] endproperty [ : property_identifier ]
property_port_list ::=
 property_port_item { , property_port_item }
property_port_item ::=
 { attribute_instance } [ local [ property_lvar_port_direction ] ] property_formal_type
 formal_port_identifier { variable_dimension } [ = property_actual_arg ]
property_lvar_port_direction ::=
 input
property_formal_type ::=
 sequence_formal_type | property
property_spec ::=
 [ clocking_event ] [ disable iff ( expression_or_dist ) ] property_expr
property_expr ::=
 sequence_expr
 | strong ( sequence_expr )
 | weak ( 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 ]
 | case ( expression_or_dist ) property_case_item { property_case_item } endcase
 | sequence_expr #-# property_expr
 | sequence_expr #=# property_expr
 | nexttime property_expr
 | nexttime [ constant _expression ] property_expr
 | s_nexttime property_expr
 | s_nexttime [ constant_expression ] property_expr
 | always property_expr
 | always [ cycle_delay_const_range_expression ] property_expr
 | s_always [ constant_range ] property_expr
 | s_eventually property_expr
 | eventually [ constant_range ] property_expr
 | s_eventually [ cycle_delay_const_range_expression ] property_expr
 | property_expr until property_expr
 | property_expr s_until property_expr
 | property_expr until_with property_expr
 | property_expr s_until_with property_expr
 | property_expr implies property_expr
 | property_expr iff property_expr
 | accept_on ( expression_or_dist ) property_expr
 | reject_on ( expression_or_dist ) property_expr
 | sync_accept_on ( expression_or_dist ) property_expr
 | sync_reject_on ( expression_or_dist ) property_expr
 | property_instance
 | clocking_event property_expr
property_case_item ::=
 expression_or_dist { , expression_or_dist } : property_expr [ ; ]
 | default [ : ] property_expr [ ; ]
sequence_declaration ::=
 sequence sequence_identifier [ ( [ sequence_port_list ] ) ] ;
 { assertion_variable_declaration } sequence_expr [ ; ] endsequence [ : sequence_identifier ]
sequence_port_list ::=
 sequence_port_item { , sequence_port_item }
sequence_port_item ::=
 { attribute_instance } [ local [ sequence_lvar_port_direction ] ] sequence_formal_type
 formal_port_identifier { variable_dimension } [ = sequence_actual_arg ]
sequence_lvar_port_direction ::=
 input | inout | output
sequence_formal_type ::=
 data_type_or_implicit | sequence | untyped
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 ]
 | 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 ::=
 ## constant_primary | ## [ 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_or_hierarchical_sequence_identifier [ ( [ sequence_list_of_arguments ] ) ]
sequence_list_of_arguments ::=
 [ sequence_actual_arg ] { , [ sequence_actual_arg ] }
 { , . identifier ( [ sequence_actual_arg ] ) }
 | . identifier ( [ sequence_actual_arg ] ) { , . identifier ( [ sequence_actual_arg ] ) }
sequence_actual_arg ::=
 event_expression | sequence_expr
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 ::=
 var_data_type list_of_variable_decl_assignments ;
let_declaration ::=
 let let_identifier [ ( [ let_port_list ] ) ] = expression ;
let_identifier ::=
 identifier
let_port_list ::=
 let_port_item { , let_port_item }
let_port_item ::=
 { attribute_instance } let_formal_type formal_port_identifier { variable_dimension }
 [ = expression ]
let_formal_type ::=
 data_type_or_implicit | untyped
let_expression ::=
 [ package_scope ] let_identifier [ ( [ let_list_of_arguments ] ) ]
let_list_of_arguments ::=
 [ let_actual_arg ] { , [ let_actual_arg ] } { , . identifier ( [ let_actual_arg ] ) }
 | . identifier ( [ let_actual_arg ] ) { , . identifier ( [ let_actual_arg ] ) }
let_actual_arg ::=
 expression 

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 = constant_expression
coverage_spec ::=
 cover_point | cover_cross
coverage_event ::=
 clocking_event | with function sample ( [ tf_port_list ] ) | @@ ( 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 ::=
 [ [ data_type_or_implicit ] 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 [ [ [ covergroup_expression ] ] ] = {
 covergroup_range_list } [ with ( with_covergroup_expression ) ] [ iff ( expression ) ]
 | [ wildcard ] bins_keyword bin_identifier [ [ [ covergroup_expression ] ] ] =
 cover_point_identifier [ with ( with_covergroup_expression ) ] [ iff ( expression ) ]
 | [ wildcard ] bins_keyword bin_identifier [ [ [ covergroup_expression ] ] ] =
 set_covergroup_expression [ iff ( expression ) ]
 | [ wildcard ] bins_keyword bin_identifier [ [ ] ] = trans_list [ iff ( expression ) ]
 | bins_keyword bin_identifier [ [ [ covergroup_expression ] ] ] = default
 [ iff ( expression ) ]
 | bins_keyword bin_identifier = default sequence [ iff ( expression ) ]
bins_keyword ::=
 bins | illegal_bins | ignore_bins
trans_list ::=
 ( trans_set ) { , ( trans_set ) }
trans_set ::=
 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 ::=
 covergroup_range_list
repeat_range ::=
 covergroup_expression | covergroup_expression : covergroup_expression
cover_cross ::=
 [ cross_identifier : ] cross list_of_cross_items [ iff ( expression ) ] cross_body
list_of_cross_items ::=
 cross_item , cross_item { , cross_item }
cross_item ::=
 cover_point_identifier | variable_identifier
cross_body ::=
 { { cross_body_item ; } } | ;
cross_body_item ::=
 function_declaraton | 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_expression with ( with_covergroup_expression )
 [ matches integer_covergroup_expression ]
 | cross_identifier
 | cross_set_expression [ matches integer_covergroup_expression ]
select_condition ::=
 binsof ( bins_expression ) [ intersect { covergroup_range_list } ]
bins_expression ::=
 variable_identifier | cover_point_identifier [ . bin_identifier ]
covergroup_range_list ::=
 covergroup_value_range { , covergroup_value_range }
covergroup_value_range ::=
 covergroup_expression | [ covergroup_expression : covergroup_expression ]
with_covergroup_expression ::=
 covergroup_expression
set_covergroup_expression ::=
 covergroup_expression
integer_covergroup_expression ::=
 covergroup_expression
cross_set_expression ::=
 covergroup_expression
covergroup_expression ::=
 expression 

gate_instantiation ::=
 cmos_switchtype [ delay3 ] cmos_switch_instance { , cmos_switch_instance } ;
 | enable_gatetype [ drive_strength ] [ delay3 ] enable_gate_instance { , enable_gate_instance }
 ;
 | mos_switchtype [ delay3 ] mos_switch_instance { , mos_switch_instance } ;
 | n_input_gatetype [ drive_strength ] [ delay2 ] n_input_gate_instance
 { , n_input_gate_instance } ;
 | n_output_gatetype [ drive_strength ] [ delay2 ] n_output_gate_instance
 { , n_output_gate_instance } ;
 | pass_en_switchtype [ delay2 ] pass_enable_switch_instance { , pass_enable_switch_instance } ;
 | pass_switchtype pass_switch_instance { , pass_switch_instance } ;
 | pulldown [ pulldown_strength ] pull_gate_instance { , pull_gate_instance } ;
 | pullup [ pullup_strength ] pull_gate_instance { , pull_gate_instance } ;
cmos_switch_instance ::=
 [ name_of_instance ] ( output_terminal , input_terminal , ncontrol_terminal ,
 pcontrol_terminal )
enable_gate_instance ::=
 [ name_of_instance ] ( output_terminal , input_terminal , enable_terminal )
mos_switch_instance ::=
 [ name_of_instance ] ( output_terminal , input_terminal , enable_terminal )
n_input_gate_instance ::=
 [ name_of_instance ] ( output_terminal , input_terminal { , input_terminal } )
n_output_gate_instance ::=
 [ name_of_instance ] ( output_terminal { , output_terminal } , input_terminal )
pass_switch_instance ::=
 [ name_of_instance ] ( inout_terminal , inout_terminal )
pass_enable_switch_instance ::=
 [ name_of_instance ] ( inout_terminal , inout_terminal , enable_terminal )
pull_gate_instance ::=
 [ name_of_instance ] ( output_terminal )

pulldown_strength ::=
 ( strength0 , strength1 ) | ( strength1 , strength0 ) | ( strength0 )
pullup_strength ::=
 ( strength0 , strength1 ) | ( strength1 , strength0 ) | ( strength1 )

enable_terminal ::=
 expression
inout_terminal ::=
 net_lvalue
input_terminal ::=
 expression
ncontrol_terminal ::=
 expression
output_terminal ::=
 net_lvalue
pcontrol_terminal ::=
 expression 

cmos_switchtype ::=
 cmos | rcmos
enable_gatetype ::=
 bufif0 | bufif1 | notif0 | notif1
mos_switchtype ::=
 nmos | pmos | rnmos | rpmos
n_input_gatetype ::=
 and | nand | or | nor | xor | xnor
n_output_gatetype ::=
 buf | not
pass_en_switchtype ::=
 tranif0 | tranif1 | rtranif1 | rtranif0
pass_switchtype ::=
 tran | rtran

module_instantiation ::=
 module_identifier [ parameter_value_assignment ] hierarchical_instance
 { , hierarchical_instance } ;
parameter_value_assignment ::=
 # ( [ list_of_parameter_assignments ] )
list_of_parameter_assignments ::=
 ordered_parameter_assignment { , ordered_parameter_assignment }
 | named_parameter_assignment { , named_parameter_assignment }
ordered_parameter_assignment ::=
 param_expression
named_parameter_assignment ::=
 . parameter_identifier ( [ param_expression ] )
hierarchical_instance ::=
 name_of_instance ( [ list_of_port_connections ] )
name_of_instance ::=
 instance_identifier { unpacked_dimension }
list_of_port_connections ::=
 ordered_port_connection { , ordered_port_connection }
 | named_port_connection { , named_port_connection }
ordered_port_connection ::=
 { attribute_instance } [ expression ]
named_port_connection ::=
 { attribute_instance } . port_identifier [ ( [ expression ] ) ] | { attribute_instance } .*

interface_instantiation ::=
 interface_identifier [ parameter_value_assignment ] hierarchical_instance
 { , hierarchical_instance } ;

program_instantiation ::=
 program_identifier [ parameter_value_assignment ] hierarchical_instance
 { , hierarchical_instance } ;

checker_instantiation ::=
 ps_checker_identifier name_of_instance ( [ list_of_checker_port_connections ] ) ;
list_of_checker_port_connections ::=
 ordered_checker_port_connection { , ordered_checker_port_connection }
 | named_checker_port_connection { , named_checker_port_connection }
ordered_checker_port_connection ::=
 { attribute_instance } [ property_actual_arg ]
named_checker_port_connection ::=
 { attribute_instance } . formal_port_identifier [ ( [ property_actual_arg ] ) ]
 | { attribute_instance } .*

generate_region ::=
 generate { generate_item } endgenerate
loop_generate_construct ::=
 for ( genvar_initialization ; genvar_expression ; genvar_iteration ) generate_block
genvar_initialization ::=
 [ genvar ] genvar_identifier = constant_expression
genvar_iteration ::=
 genvar_identifier assignment_operator genvar_expression
 | inc_or_dec_operator genvar_identifier
 | genvar_identifier inc_or_dec_operator
conditional_generate_construct ::=
 if_generate_construct | case_generate_construct
if_generate_construct ::=
 if ( constant_expression ) generate_block [ else generate_block ]
case_generate_construct ::=
 case ( constant_expression ) case_generate_item { case_generate_item } endcase
case_generate_item ::=
 constant_expression { , constant_expression } : generate_block | default [ : ] generate_block
generate_block ::=
 generate_item
 | [ generate_block_identifier : ] begin [ : generate_block_identifier ] { generate_item } end
 [ : generate_block_identifier ]
generate_item ::=
 module_or_generate_item | interface_or_generate_item | checker_or_generate_item 

udp_nonansi_declaration ::=
 { attribute_instance } primitive udp_identifier ( udp_port_list ) ;
udp_ansi_declaration ::=
 { attribute_instance } primitive udp_identifier ( udp_declaration_port_list ) ;
udp_declaration ::=
 udp_nonansi_declaration udp_port_declaration { udp_port_declaration } udp_body endprimitive
 [ : udp_identifier ]
 | udp_ansi_declaration udp_body endprimitive [ : udp_identifier ]
 | extern udp_nonansi_declaration
 | extern udp_ansi_declaration
 | { attribute_instance } primitive udp_identifier ( .* ) ; { udp_port_declaration } udp_body
 endprimitive [ : udp_identifier ]

udp_port_list ::=
 output_port_identifier , input_port_identifier { , input_port_identifier }
udp_declaration_port_list ::=
 udp_output_declaration , udp_input_declaration { , udp_input_declaration }
udp_port_declaration ::=
 udp_output_declaration ; | udp_input_declaration ; | udp_reg_declaration ;
udp_output_declaration ::=
 { attribute_instance } output port_identifier
 | { attribute_instance } output reg port_identifier [ = constant_expression ]
udp_input_declaration ::=
 { attribute_instance } input list_of_udp_port_identifiers
udp_reg_declaration ::=
 { attribute_instance } reg variable_identifier 

udp_body ::=
 combinational_body | sequential_body
combinational_body ::=
 table combinational_entry { combinational_entry } endtable
combinational_entry ::=
 level_input_list : output_symbol ;
sequential_body ::=
 [ udp_initial_statement ] table sequential_entry { sequential_entry } endtable
udp_initial_statement ::=
 initial output_port_identifier = init_val ;
init_val ::=
 1'b0 | 1'b1 | 1'bx | 1'bX | 1'B0 | 1'B1 | 1'Bx | 1'BX | 1 | 0
sequential_entry ::=
 seq_input_list : current_state : next_state ;
seq_input_list ::=
 level_input_list | edge_input_list
level_input_list ::=
 level_symbol { level_symbol }
edge_input_list ::=
 { level_symbol } edge_indicator { level_symbol }
edge_indicator ::=
 ( level_symbol level_symbol ) | edge_symbol
current_state ::=
 level_symbol
next_state ::=
 output_symbol | -
output_symbol ::=
 0 | 1 | x | X
level_symbol ::=
 0 | 1 | x | X | ? | b | B
edge_symbol ::=
 r | R | f | F | p | P | n | N | *

udp_instantiation ::=
 udp_identifier [ drive_strength ] [ delay2 ] udp_instance { , udp_instance } ;
udp_instance ::=
 [ name_of_instance ] ( output_terminal , input_terminal { , input_terminal } )

continuous_assign ::=
 assign [ drive_strength ] [ delay3 ] list_of_net_assignments ;
 | assign [ delay_control ] list_of_variable_assignments ;
list_of_net_assignments ::=
 net_assignment { , net_assignment }
list_of_variable_assignments ::=
 variable_assignment { , variable_assignment }
net_alias ::=
 alias net_lvalue = net_lvalue { = net_lvalue } ;
net_assignment ::=
 net_lvalue = expression 

initial_construct ::=
 initial statement_or_null
always_construct ::=
 always_keyword statement
always_keyword ::=
 always | always_comb | always_latch | always_ff
final_construct ::=
 final function_statement
blocking_assignment ::=
 variable_lvalue = delay_or_event_control expression
 | nonrange_variable_lvalue = dynamic_array_new
 | [ implicit_class_handle . | class_scope | package_scope ] hierarchical_variable_identifier
 select != class_new
 | operator_assignment
operator_assignment ::=
 variable_lvalue assignment_operator expression
assignment_operator ::=
 = | += | -= | *= | /= | %= | &= | |= | ^= | <<= | >>= | <<<= | >>>=
nonblocking_assignment ::=
 variable_lvalue <= [ delay_or_event_control ] expression
procedural_continuous_assignment ::=
 assign variable_assignment
 | deassign variable_lvalue
 | force variable_assignment
 | force net_assignment
 | release variable_lvalue
 | release net_lvalue
variable_assignment ::=
 variable_lvalue = expression 

action_block ::=
 statement_or_null | [ statement ] else statement_or_null
seq_block ::=
 begin [ : block_identifier ] { block_item_declaration } { statement_or_null } end
 [ : block_identifier ]
par_block ::=
 fork [ : block_identifier ] { block_item_declaration } { statement_or_null } join_keyword
 [ : block_identifier ]
join_keyword ::=
 join | join_any | join_none

statement_or_null ::=
 statement | { attribute_instance } ;
statement ::=
 [ block_identifier : ] { attribute_instance } statement_item
statement_item ::=
 blocking_assignment ;
 | nonblocking_assignment ;
 | procedural_continuous_assignment ;
 | case_statement
 | conditional_statement
 | inc_or_dec_expression ;
 | subroutine_call_statement
 | disable_statement
 | event_trigger
 | loop_statement
 | jump_statement
 | par_block
 | procedural_timing_control_statement
 | seq_block
 | wait_statement
 | procedural_assertion_statement
 | clocking_drive ;
 | randsequence_statement
 | randcase_statement
 | expect_property_statement
function_statement ::=
 statement
function_statement_or_null ::=
 function_statement | { attribute_instance } ;
variable_identifier_list ::=
 variable_identifier { , variable_identifier }

procedural_timing_control_statement ::=
 procedural_timing_control statement_or_null
delay_or_event_control ::=
 delay_control | event_control | repeat ( expression ) event_control
delay_control ::=
 # delay_value | # ( mintypmax_expression )
event_control ::=
 @ hierarchical_event_identifier
 | @ ( event_expression )
 | @*
 | @ (*)
 | @ ps_or_hierarchical_sequence_identifier
event_expression ::=
 [ edge_identifier ] expression [ iff expression ]
 | sequence_instance [ iff expression ]
 | event_expression or event_expression
 | event_expression , event_expression
 | ( event_expression )
procedural_timing_control ::=
 delay_control | event_control | cycle_delay
jump_statement ::=
 return [ expression ] ; | break ; | continue ;
wait_statement ::=
 wait ( expression ) statement_or_null
 | wait fork ;
 | wait_order ( hierarchical_identifier { , hierarchical_identifier } ) action_block
event_trigger ::=
 -> hierarchical_event_identifier ;
 | ->> [ delay_or_event_control ] hierarchical_event_identifier ;
disable_statement ::=
 disable hierarchical_task_identifier ;
 | disable hierarchical_block_identifier ;
 | disable fork ;

conditional_statement ::=
 [ unique_priority ] if ( cond_predicate ) statement_or_null
 { else if ( cond_predicate ) statement_or_null } [ else statement_or_null ]
unique_priority ::=
 unique | unique0 | priority
cond_predicate ::=
 expression_or_cond_pattern { &&& expression_or_cond_pattern }
expression_or_cond_pattern ::=
 expression | cond_pattern
cond_pattern ::=
 expression matches pattern 

case_statement ::=
 [ unique_priority ] case_keyword ( case_expression ) case_item { case_item } endcase
 | [ unique_priority ] case_keyword ( case_expression ) matches case_pattern_item
 { case_pattern_item } endcase
 | [ unique_priority ] case ( case_expression ) inside case_inside_item { case_inside_item }
 endcase
case_keyword ::=
 case | casez | casex
case_expression ::=
 expression
case_item ::=
 case_item_expression { , case_item_expression } : statement_or_null
 | default [ : ] statement_or_null
case_pattern_item ::=
 pattern [ &&& expression ] : statement_or_null | default [ : ] statement_or_null
case_inside_item ::=
 open_range_list : statement_or_null | default [ : ] statement_or_null
case_item_expression ::=
 expression
randcase_statement ::=
 randcase randcase_item { randcase_item } endcase
randcase_item ::=
 expression : statement_or_null
open_range_list ::=
 open_value_range { , open_value_range }
open_value_range ::=
 value_range 

pattern ::=
 . variable_identifier
 | .*
 | constant_expression
 | tagged member_identifier [ pattern ]
 | '{ pattern { , pattern } }
 | '{ member_identifier : pattern { , member_identifier : pattern } }
assignment_pattern ::=
 '{ expression { , expression } }
 | '{ structure_pattern_key : expression { , structure_pattern_key : expression } }
 | '{ array_pattern_key : expression { , array_pattern_key : expression } }
 | '{ constant_expression { expression { , expression } } }
structure_pattern_key ::=
 member_identifier | assignment_pattern_key
array_pattern_key ::=
 constant_expression | assignment_pattern_key
assignment_pattern_key ::=
 simple_type | default
assignment_pattern_expression ::=
 [ assignment_pattern_expression_type ] assignment_pattern
assignment_pattern_expression_type ::=
 ps_type_identifier | ps_parameter_identifier | integer_atom_type | type_reference
constant_assignment_pattern_expression ::=
 assignment_pattern_expression
assignment_pattern_net_lvalue ::=
 '{ net_lvalue { , net_lvalue } }
assignment_pattern_variable_lvalue ::=
 '{ variable_lvalue { , variable_lvalue } }

loop_statement ::=
 forever statement_or_null
 | repeat ( expression ) statement_or_null
 | while ( expression ) statement_or_null
 | for ( [ for_initialization ] ; [ expression ] ; [ for_step ] ) statement_or_null
 | do statement_or_null while ( expression ) ;
 | foreach ( ps_or_hierarchical_array_identifier [ loop_variables ] ) statement
for_initialization ::=
 list_of_variable_assignments | for_variable_declaration { , for_variable_declaration }
for_variable_declaration ::=
 [ var ] data_type variable_identifier = expression { , variable_identifier = expression }
for_step ::=
 for_step_assignment { , for_step_assignment }
for_step_assignment ::=
 operator_assignment | inc_or_dec_expression | function_subroutine_call
loop_variables ::=
 [ index_variable_identifier ] { , [ index_variable_identifier ] }

subroutine_call_statement ::=
 subroutine_call ; | void ' ( function_subroutine_call ) ;

assertion_item ::=
 concurrent_assertion_item | deferred_immediate_assertion_item
deferred_immediate_assertion_item ::=
 [ block_identifier : ] deferred_immediate_assertion_statement
procedural_assertion_statement ::=
 concurrent_assertion_statement | immediate_assertion_statement | checker_instantiation
immediate_assertion_statement ::=
 simple_immediate_assertion_statement | deferred_immediate_assertion_statement
simple_immediate_assertion_statement ::=
 simple_immediate_assert_statement
 | simple_immediate_assume_statement
 | simple_immediate_cover_statement
simple_immediate_assert_statement ::=
 assert ( expression ) action_block
simple_immediate_assume_statement ::=
 assume ( expression ) action_block
simple_immediate_cover_statement ::=
 cover ( expression ) statement_or_null
deferred_immediate_assertion_statement ::=
 deferred_immediate_assert_statement
 | deferred_immediate_assume_statement
 | deferred_immediate_cover_statement
deferred_immediate_assert_statement ::=
 assert #0 ( expression ) action_block | assert final ( expression ) action_block
deferred_immediate_assume_statement ::=
 assume #0 ( expression ) action_block | assume final ( expression ) action_block
deferred_immediate_cover_statement ::=
 cover #0 ( expression ) statement_or_null | cover final ( expression ) statement_or_null 

clocking_declaration ::=
 [ default ] clocking [ clocking_identifier ] clocking_event ; { clocking_item } endclocking
 [ : clocking_identifier ]
 | global clocking [ clocking_identifier ] clocking_event ; endclocking [ : clocking_identifier ]
clocking_event ::=
 @ identifier | @ ( event_expression )
clocking_item ::=
 default default_skew ;
 | clocking_direction list_of_clocking_decl_assign ;
 | { attribute_instance } assertion_item_declaration
default_skew ::=
 input clocking_skew | output clocking_skew | input clocking_skew output clocking_skew
clocking_direction ::=
 input [ clocking_skew ]
 | output [ clocking_skew ]
 | input [ clocking_skew ] output [ clocking_skew ]
 | inout
list_of_clocking_decl_assign ::=
 clocking_decl_assign { , clocking_decl_assign }
clocking_decl_assign ::=
 signal_identifier [ = expression ]
clocking_skew ::=
 edge_identifier [ delay_control ] | delay_control
clocking_drive ::=
 clockvar_expression <= [ cycle_delay ] expression
cycle_delay ::=
 ## integral_number | ## identifier | ## ( expression )
clockvar ::=
 hierarchical_identifier
clockvar_expression ::=
 clockvar select 

randsequence_statement ::=
 randsequence ( [ production_identifier ] ) production { production } endsequence
production ::=
 [ data_type_or_void ] production_identifier [ ( tf_port_list ) ] : rs_rule { | rs_rule } ;
rs_rule ::=
 rs_production_list [ := weight_specification [ rs_code_block ] ]
rs_production_list ::=
 rs_prod { rs_prod }
 | rand join [ ( expression ) ] production_item production_item { production_item }
weight_specification ::=
 integral_number | ps_identifier ( expression )
rs_code_block ::=
 { { data_declaration } { statement_or_null } }
rs_prod ::=
 production_item | rs_code_block | rs_if_else | rs_repeat | rs_case
production_item ::=
 production_identifier [ ( list_of_arguments ) ]
rs_if_else ::=
 if ( expression ) production_item [ else production_item ]
rs_repeat ::=
 repeat ( expression ) production_item
rs_case ::=
 case ( case_expression ) rs_case_item { rs_case_item } endcase
rs_case_item ::=
 case_item_expression { , case_item_expression } : production_item ;
 | default [ : ] production_item ;

specify_block ::=
 specify { specify_item } endspecify
specify_item ::=
 specparam_declaration
 | pulsestyle_declaration
 | showcancelled_declaration
 | path_declaration
 | system_timing_check
pulsestyle_declaration ::=
 pulsestyle_onevent list_of_path_outputs ; | pulsestyle_ondetect list_of_path_outputs ;
showcancelled_declaration ::=
 showcancelled list_of_path_outputs ; | noshowcancelled list_of_path_outputs ;

path_declaration ::=
 simple_path_declaration ;
 | edge_sensitive_path_declaration ;
 | state_dependent_path_declaration ;
simple_path_declaration ::=
 parallel_path_description = path_delay_value | full_path_description = path_delay_value
parallel_path_description ::=
 ( specify_input_terminal_descriptor [ polarity_operator ] =>
 specify_output_terminal_descriptor )
full_path_description ::=
 ( list_of_path_inputs [ polarity_operator ] *> list_of_path_outputs )
list_of_path_inputs ::=
 specify_input_terminal_descriptor { , specify_input_terminal_descriptor }
list_of_path_outputs ::=
 specify_output_terminal_descriptor { , specify_output_terminal_descriptor }

specify_input_terminal_descriptor ::=
 input_identifier [ [ constant_range_expression ] ]
specify_output_terminal_descriptor ::=
 output_identifier [ [ constant_range_expression ] ]
input_identifier ::=
 input_port_identifier | inout_port_identifier | interface_identifier . port_identifier
output_identifier ::=
 output_port_identifier | inout_port_identifier | interface_identifier . port_identifier 

path_delay_value ::=
 list_of_path_delay_expressions | ( list_of_path_delay_expressions )
list_of_path_delay_expressions ::=
 t_path_delay_expression
 | trise_path_delay_expression , tfall_path_delay_expression
 | trise_path_delay_expression , tfall_path_delay_expression , tz_path_delay_expression
 | t01_path_delay_expression , t10_path_delay_expression , t0z_path_delay_expression ,
 tz1_path_delay_expression , t1z_path_delay_expression , tz0_path_delay_expression
 | t01_path_delay_expression , t10_path_delay_expression , t0z_path_delay_expression ,
 tz1_path_delay_expression , t1z_path_delay_expression , tz0_path_delay_expression ,
 t0x_path_delay_expression , tx1_path_delay_expression , t1x_path_delay_expression ,
 tx0_path_delay_expression , txz_path_delay_expression , tzx_path_delay_expression
t_path_delay_expression ::=
 path_delay_expression
trise_path_delay_expression ::=
 path_delay_expression
tfall_path_delay_expression ::=
 path_delay_expression
tz_path_delay_expression ::=
 path_delay_expression
t01_path_delay_expression ::=
 path_delay_expression
t10_path_delay_expression ::=
 path_delay_expression
t0z_path_delay_expression ::=
 path_delay_expression
tz1_path_delay_expression ::=
 path_delay_expression
t1z_path_delay_expression ::=
 path_delay_expression
tz0_path_delay_expression ::=
 path_delay_expression
t0x_path_delay_expression ::=
 path_delay_expression
tx1_path_delay_expression ::=
 path_delay_expression
t1x_path_delay_expression ::=
 path_delay_expression
tx0_path_delay_expression ::=
 path_delay_expression
txz_path_delay_expression ::=
 path_delay_expression
tzx_path_delay_expression ::=
 path_delay_expression
path_delay_expression ::=
 constant_mintypmax_expression
edge_sensitive_path_declaration ::=
 parallel_edge_sensitive_path_description = path_delay_value
 | full_edge_sensitive_path_description = path_delay_value
parallel_edge_sensitive_path_description ::=
 ( [ edge_identifier ] specify_input_terminal_descriptor [ polarity_operator ] => (
 specify_output_terminal_descriptor [ polarity_operator ] : data_source_expression ) )
full_edge_sensitive_path_description ::=
 ( [ edge_identifier ] list_of_path_inputs [ polarity_operator ] *> ( list_of_path_outputs
 [ polarity_operator ] : data_source_expression ) )
data_source_expression ::=
 expression
edge_identifier ::=
 posedge | negedge | edge
state_dependent_path_declaration ::=
 if ( module_path_expression ) simple_path_declaration
 | if ( module_path_expression ) edge_sensitive_path_declaration
 | ifnone simple_path_declaration
polarity_operator ::=
 + | -

system_timing_check ::=
 setup_timing_check
 | hold_timing_check
 | setuphold_timing_check
 | recovery_timing_check
 | removal_timing_check
 | recrem_timing_check
 | skew_timing_check
 | timeskew_timing_check
 | fullskew_timing_check
 | period_timing_check
 | width_timing_check
 | nochange_timing_check
setup_timing_check ::=
 $setup ( data_event , reference_event , timing_check_limit [ , [ notifier ] ] ) ;
hold_timing_check ::=
 $hold ( reference_event , data_event , timing_check_limit [ , [ notifier ] ] ) ;
setuphold_timing_check ::=
 $setuphold ( reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notifier ]
 [ , [ timestamp_condition ]
 [ , [ timecheck_condition ] [ , [ delayed_reference ] [ , [ delayed_data ] ] ] ] ] ]
 ) ;
recovery_timing_check ::=
 $recovery ( reference_event , data_event , timing_check_limit [ , [ notifier ] ] ) ;
removal_timing_check ::=
 $removal ( reference_event , data_event , timing_check_limit [ , [ notifier ] ] ) ;
recrem_timing_check ::=
 $recrem ( reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notifier ]
 [ , [ timestamp_condition ]
 [ , [ timecheck_condition ] [ , [ delayed_reference ] [ , [ delayed_data ] ] ] ] ] ]
 ) ;
skew_timing_check ::=
 $skew ( reference_event , data_event , timing_check_limit [ , [ notifier ] ] ) ;
timeskew_timing_check ::=
 $timeskew ( reference_event , data_event , timing_check_limit
 [ , [ notifier ] [ , [ event_based_flag ] [ , [ remain_active_flag ] ] ] ] ) ;
fullskew_timing_check ::=
 $fullskew ( reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notifier ] [ , [ event_based_flag ] [ , [ remain_active_flag ] ] ] ] ) ;
period_timing_check ::=
 $period ( controlled_reference_event , timing_check_limit [ , [ notifier ] ] ) ;
width_timing_check ::=
 $width ( controlled_reference_event , timing_check_limit , threshold [ , [ notifier ] ] ) ;
nochange_timing_check ::=
 $nochange ( reference_event , data_event , start_edge_offset , end_edge_offset
 [ , [ notifier ] ] ) ;

timecheck_condition ::=
 mintypmax_expression
controlled_reference_event ::=
 controlled_timing_check_event
data_event ::=
 timing_check_event
delayed_data ::=
 terminal_identifier | terminal_identifier [ constant_mintypmax_expression ]
delayed_reference ::=
 terminal_identifier | terminal_identifier [ constant_mintypmax_expression ]
end_edge_offset ::=
 mintypmax_expression
event_based_flag ::=
 constant_expression
notifier ::=
 variable_identifier
reference_event ::=
 timing_check_event
remain_active_flag ::=
 constant_mintypmax_expression
timestamp_condition ::=
 mintypmax_expression
start_edge_offset ::=
 mintypmax_expression
threshold ::=
 constant_expression
timing_check_limit ::=
 expression 

timing_check_event ::=
 [ timing_check_event_control ] specify_terminal_descriptor [ &&& timing_check_condition ]
controlled_timing_check_event ::=
 timing_check_event_control specify_terminal_descriptor [ &&& timing_check_condition ]
timing_check_event_control ::=
 posedge | negedge | edge | edge_control_specifier
specify_terminal_descriptor ::=
 specify_input_terminal_descriptor | specify_output_terminal_descriptor
edge_control_specifier ::=
 edge [ edge_descriptor { , edge_descriptor } ]
edge_descriptor ::=!
 01 | 10 | z_or_x zero_or_one | zero_or_one z_or_x
zero_or_one ::=
 0 | 1
z_or_x ::=
 x | X | z | Z
timing_check_condition ::=
 scalar_timing_check_condition | ( scalar_timing_check_condition )
scalar_timing_check_condition ::=
 expression
 | ~ expression
 | expression == scalar_constant
 | expression === scalar_constant
 | expression != scalar_constant
 | expression !== scalar_constant
scalar_constant ::=
 1'b0 | 1'b1 | 1'B0 | 1'B1 | 'b0 | 'b1 | 'B0 | 'B1 | 1 | 0

concatenation ::=
 { expression { , expression } }
constant_concatenation ::=
 { constant_expression { , constant_expression } }
constant_multiple_concatenation ::=
 { constant_expression constant_concatenation }
module_path_concatenation ::=
 { module_path_expression { , module_path_expression } }
module_path_multiple_concatenation ::=
 { constant_expression module_path_concatenation }
multiple_concatenation ::=
 { expression concatenation }
streaming_concatenation ::=
 { stream_operator [ slice_size ] stream_concatenation }
stream_operator ::=
 >> | <<
slice_size ::=
 simple_type | constant_expression
stream_concatenation ::=
 { stream_expression { , stream_expression } }
stream_expression ::=
 expression [ with [ array_range_expression ] ]
array_range_expression ::=
 expression | expression : expression | expression +: expression | expression -: expression
empty_queue ::=
 { }

constant_function_call ::=
 function_subroutine_call
tf_call ::=
 ps_or_hierarchical_tf_identifier { attribute_instance } [ ( list_of_arguments ) ]
system_tf_call ::=
 system_tf_identifier [ ( list_of_arguments ) ]
 | system_tf_identifier ( data_type [ , expression ] )
subroutine_call ::=
 tf_call | system_tf_call | method_call | [ std:: ] randomize_call
function_subroutine_call ::=
 subroutine_call
list_of_arguments ::=
 [ expression ] { , [ expression ] } { , . identifier ( [ expression ] ) }
 | . identifier ( [ expression ] ) { , . identifier ( [ expression ] ) }
method_call ::=
 method_call_root . method_call_body
method_call_body ::=
 method_identifier { attribute_instance } [ ( list_of_arguments ) ] | built_in_method_call
built_in_method_call ::=
 array_manipulation_call | randomize_call
array_manipulation_call ::=
 array_method_name { attribute_instance } [ ( list_of_arguments ) ] [ with ( expression ) ]
randomize_call ::=
 randomize { attribute_instance } [ ( [ variable_identifier_list | null ] ) ]
 [ with [ ( [ identifier_list ] ) ] constraint_block ]
method_call_root ::=
 primary | implicit_class_handle
array_method_name ::=
 method_identifier | unique | and | or | xor

inc_or_dec_expression ::=
 inc_or_dec_operator { attribute_instance } variable_lvalue
 | variable_lvalue { attribute_instance } inc_or_dec_operator
conditional_expression ::=
 cond_predicate ? { attribute_instance } expression : expression
constant_expression ::=
 constant_primary
 | unary_operator { attribute_instance } constant_primary
 | constant_expression binary_operator { attribute_instance } constant_expression
 | constant_expression ? { attribute_instance } constant_expression : constant_expression
constant_mintypmax_expression ::=
 constant_expression | constant_expression : constant_expression : constant_expression
constant_param_expression ::=
 constant_mintypmax_expression | data_type | $
param_expression ::=
 mintypmax_expression | data_type | $
constant_range_expression ::=
 constant_expression | constant_part_select_range
constant_part_select_range ::=
 constant_range | constant_indexed_range
constant_range ::=
 constant_expression : constant_expression
constant_indexed_range ::=
 constant_expression +: constant_expression | constant_expression -: constant_expression
expression ::=
 primary
 | unary_operator { attribute_instance } primary
 | inc_or_dec_expression
 | ( operator_assignment )
 | expression binary_operator { attribute_instance } expression
 | conditional_expression
 | inside_expression
 | tagged_union_expression
tagged_union_expression ::=
 tagged member_identifier [ expression ]
inside_expression ::=
 expression inside { open_range_list }
value_range ::=
 expression | [ expression : expression ]
mintypmax_expression ::=
 expression | expression : expression : expression
module_path_conditional_expression ::=
 module_path_expression ? { attribute_instance } module_path_expression :
 module_path_expression
module_path_expression ::=
 module_path_primary
 | unary_module_path_operator { attribute_instance } module_path_primary
 | module_path_expression binary_module_path_operator { attribute_instance }
 module_path_expression
 | module_path_conditional_expression
module_path_mintypmax_expression ::=
 module_path_expression
 | module_path_expression : module_path_expression : module_path_expression
part_select_range ::=
 constant_range | indexed_range
indexed_range ::=
 expression +: constant_expression | expression -: constant_expression
genvar_expression ::=
 constant_expression 

constant_primary ::=
 primary_literal
 | ps_parameter_identifier constant_select
 | specparam_identifier [ [ constant_range_expression ] ]
 | genvar_identifier
 | formal_port_identifier constant_select
 | [ package_scope | class_scope ] enum_identifier
 | constant_concatenation [ [ constant_range_expression ] ]
 | constant_multiple_concatenation [ [ constant_range_expression ] ]
 | constant_function_call
 | constant_let_expression
 | ( constant_mintypmax_expression )
 | constant_cast
 | constant_assignment_pattern_expression
 | type_reference
module_path_primary ::=
 number
 | identifier
 | module_path_concatenation
 | module_path_multiple_concatenation
 | function_subroutine_call
 | ( module_path_mintypmax_expression )
primary ::=
 primary_literal
 | [ class_qualifier | package_scope ] hierarchical_identifier select
 | empty_queue
 | concatenation [ [ range_expression ] ]
 | multiple_concatenation [ [ range_expression ] ]
 | function_subroutine_call
 | let_expression
 | ( mintypmax_expression )
 | cast
 | assignment_pattern_expression
 | streaming_concatenation
 | sequence_method_call
 | this
 | $
 | null
class_qualifier ::=
 [ local:: ] [ implicit_class_handle . | class_scope ]
range_expression ::=
 expression | part_select_range
primary_literal ::=
 number | time_literal | unbased_unsized_literal | string_literal
time_literal ::=
 unsigned_number time_unit | fixed_point_number time_unit
time_unit ::=
 s | ms | us | ns | ps | fs
implicit_class_handle ::=
 this | super | this . super
bit_select ::=
 { [ expression ] }
select ::=
 [ { . member_identifier bit_select } . member_identifier ] bit_select
 [ [ part_select_range ] ]
nonrange_select ::=
 [ { . member_identifier bit_select } . member_identifier ] bit_select
constant_bit_select ::=
 { [ constant_expression ] }
constant_select ::=
 [ { . member_identifier constant_bit_select } . member_identifier ] constant_bit_select
 [ [ constant_part_select_range ] ]
constant_cast ::=
 casting_type ' ( constant_expression )
constant_let_expression ::=
 let_expression
cast ::=
 casting_type ' ( expression )

net_lvalue ::=
 ps_or_hierarchical_net_identifier constant_select
 | { net_lvalue { , net_lvalue } }
 | [ assignment_pattern_expression_type ] assignment_pattern_net_lvalue
variable_lvalue ::=
 [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
 | { variable_lvalue { , variable_lvalue } }
 | [ assignment_pattern_expression_type ] assignment_pattern_variable_lvalue
 | streaming_concatenation
nonrange_variable_lvalue ::=
 [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier nonrange_select 

unary_operator ::=
 + | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~
binary_operator ::=
 +
 | -
 | *
 | /
 | %
 | ==
 | !=
 | ===
 | !==
 | ==?
 | !=?
 | &&
 | ||
 | **
 | <
 | <=
 | >
 | >=
 | &
 | |
 | ^
 | ^~
 | ~^
 | >>
 | <<
 | >>>
 | <<<
 | ->
 | <->
inc_or_dec_operator ::=
 ++ | --
unary_module_path_operator ::=
 ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~
binary_module_path_operator ::=
 == | != | && | || | & | | | ^ | ^~ | ~^

number ::=
 integral_number | real_number
integral_number ::=
 decimal_number | octal_number | binary_number | hex_number
decimal_number ::=
 unsigned_number
 | [ size ] decimal_base unsigned_number
 | [ size ] decimal_base x_digit { _ }
 | [ size ] decimal_base z_digit { _ }
binary_number ::=
 [ size ] binary_base binary_value
octal_number ::=
 [ size ] octal_base octal_value
hex_number ::=
 [ size ] hex_base hex_value
sign ::=
 + | -
size ::=
 non_zero_unsigned_number
non_zero_unsigned_number ::=!
 non_zero_decimal_digit { _ | decimal_digit }
real_number ::=!
 fixed_point_number | unsigned_number [ . unsigned_number ] exp [ sign ] unsigned_number
fixed_point_number ::=!
 unsigned_number . unsigned_number
exp ::=
 e | E
unsigned_number ::=!
 decimal_digit { _ | decimal_digit }
binary_value ::=!
 binary_digit { _ | binary_digit }
octal_value ::=!
 octal_digit { _ | octal_digit }
hex_value ::=!
 hex_digit { _ | hex_digit }
decimal_base ::=!
 ' [ s | S ] d | ' [ s | S ] D
binary_base ::=!
 ' [ s | S ] b | ' [ s | S ] B
octal_base ::=!
 ' [ s | S ] o | ' [ s | S ] O
hex_base ::=!
 ' [ s | S ] h | ' [ s | S ] H
non_zero_decimal_digit ::=
 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
decimal_digit ::=
 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
binary_digit ::=
 x_digit | z_digit | 0 | 1
octal_digit ::=
 x_digit | z_digit | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
hex_digit ::=
 x_digit
 | z_digit
 | 0
 | 1
 | 2
 | 3
 | 4
 | 5
 | 6
 | 7
 | 8
 | 9
 | a
 | b
 | c
 | d
 | e
 | f
 | A
 | B
 | C
 | D
 | E
 | F
x_digit ::=
 x | X
z_digit ::=
 z | Z | ?
unbased_unsized_literal ::=
 '0 | '1 | 'z_or_x

string_literal ::=
 " { Any_ASCII_Characters } "

attribute_instance ::=
 (* attr_spec { , attr_spec } *)
attr_spec ::=
 attr_name [ = constant_expression ]
attr_name ::=
 identifier 

comment ::=
 one_line_comment | block_comment
one_line_comment ::=
 // comment_text new_line_char
block_comment ::=
 /* comment_text */
comment_text ::=
 { Any_ASCII_character }

array_identifier ::=
 identifier
block_identifier ::=
 identifier
bin_identifier ::=
 identifier
c_identifier ::=
 [ a-zA-Z_ ] { [ a-zA-Z0-9_ ] }
cell_identifier ::=
 identifier
checker_identifier ::=
 identifier
class_identifier ::=
 identifier
class_variable_identifier ::=
 variable_identifier
clocking_identifier ::=
 identifier
config_identifier ::=
 identifier
const_identifier ::=
 identifier
constraint_identifier ::=
 identifier
covergroup_identifier ::=
 identifier
covergroup_variable_identifier ::=
 variable_identifier
cover_point_identifier ::=
 identifier
cross_identifier ::=
 identifier
dynamic_array_variable_identifier ::=
 variable_identifier
enum_identifier ::=
 identifier
escaped_identifier ::=
 \ { any_printable_ASCII_character_except_white_space } white_space
formal_identifier ::=
 identifier
formal_port_identifier ::=
 identifier
function_identifier ::=
 identifier
generate_block_identifier ::=
 identifier
genvar_identifier ::=
 identifier
hierarchical_array_identifier ::=
 hierarchical_identifier
hierarchical_block_identifier ::=
 hierarchical_identifier
hierarchical_event_identifier ::=
 hierarchical_identifier
hierarchical_identifier ::=
 [ $root . ] { identifier constant_bit_select . } identifier
hierarchical_net_identifier ::=
 hierarchical_identifier
hierarchical_parameter_identifier ::=
 hierarchical_identifier
hierarchical_property_identifier ::=
 hierarchical_identifier
hierarchical_sequence_identifier ::=
 hierarchical_identifier
hierarchical_task_identifier ::=
 hierarchical_identifier
hierarchical_tf_identifier ::=
 hierarchical_identifier
hierarchical_variable_identifier ::=
 hierarchical_identifier
identifier ::=
 simple_identifier | escaped_identifier
index_variable_identifier ::=
 identifier
interface_identifier ::=
 identifier
interface_instance_identifier ::=
 identifier
inout_port_identifier ::=
 identifier
input_port_identifier ::=
 identifier
instance_identifier ::=
 identifier
library_identifier ::=
 identifier
member_identifier ::=
 identifier
method_identifier ::=
 identifier
modport_identifier ::=
 identifier
module_identifier ::=
 identifier
net_identifier ::=
 identifier
net_type_identifier ::=
 identifier
output_port_identifier ::=
 identifier
package_identifier ::=
 identifier
package_scope ::=
 package_identifier :: | $unit ::
parameter_identifier ::=
 identifier
port_identifier ::=
 identifier
production_identifier ::=
 identifier
program_identifier ::=
 identifier
property_identifier ::=
 identifier
ps_class_identifier ::=
 [ package_scope ] class_identifier
ps_covergroup_identifier ::=
 [ package_scope ] covergroup_identifier
ps_checker_identifier ::=
 [ package_scope ] checker_identifier
ps_identifier ::=
 [ package_scope ] identifier
ps_or_hierarchical_array_identifier ::=
 [ implicit_class_handle . | class_scope | package_scope ] hierarchical_array_identifier
ps_or_hierarchical_net_identifier ::=
 [ package_scope ] net_identifier | hierarchical_net_identifier
ps_or_hierarchical_property_identifier ::=
 [ package_scope ] property_identifier | hierarchical_property_identifier
ps_or_hierarchical_sequence_identifier ::=
 [ package_scope ] sequence_identifier | hierarchical_sequence_identifier
ps_or_hierarchical_tf_identifier ::=
 [ package_scope ] tf_identifier | hierarchical_tf_identifier
ps_parameter_identifier ::=
 [ package_scope | class_scope ] parameter_identifier
 | { generate_block_identifier [ [ constant_expression ] ] . } parameter_identifier
ps_type_identifier ::=
 [ local:: | package_scope ] type_identifier
sequence_identifier ::=
 identifier
signal_identifier ::=
 identifier
simple_identifier ::=
 [ a-zA-Z_ ] { [ a-zA-Z0-9_$ ] }
specparam_identifier ::=
 identifier
system_tf_identifier ::=
 $ [ a-zA-Z0-9_$ ] { [ a-zA-Z0-9_$ ] }
task_identifier ::=
 identifier
tf_identifier ::=
 identifier
terminal_identifier ::=
 identifier
topmodule_identifier ::=
 identifier
type_identifier ::=
 identifier
udp_identifier ::=
 identifier
variable_identifier ::=
 identifier