Annex A
Formal Syntax

A.1 Source text

A.1.1 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> ;

A.1.2 Configuration source text

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

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 ]

A.1.3 Module and primitive source text

source_text ::= [ timeunits_declaration ] { description }

description ::=
module_declaration
| udp_declaration
| module_root_item
| statement_or_null

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 ::=
{ attribute_instance } [ virtual ] class [ lifetime ] class_identifier [ parameter_port_list ]
[ extends class_identifier ] ; [ timeunits_declaration ] { class_item }
endclass [ : class_identifier]

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

A.1.4 Module parameters and ports

parameter_port_list ::= # ( parameter_declaration { , parameter_declaration } )

list_of_ports ::= ( port { , port } )

list_of_port_declarations ::=
( port_declaration { , port_declaration } )
| ( )

non_generic_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_range_expression ] ]

port_declaration ::=
non_generic_port_declaration
| { attribute_instance } generic_interface_port_declaration

A.1.5 Module items

module_common_item ::=
{ attribute_instance } module_or_generate_item_declaration
| { attribute_instance } interface_instantiation
| { attribute_instance } program_instantiation
| { attribute_instance } concurrent_assertion_item
| { attribute_instance } template_instantiation
| { attribute_instance } bind_directive

module_item ::=
non_generic_port_declaration ; | non_port_module_item

module_or_generate_item ::=
{ attribute_instance } parameter_override
| { attribute_instance } continuous_assign
| { attribute_instance } gate_instantiation
| { attribute_instance } udp_instantiation
| { attribute_instance } module_instantiation
| { attribute_instance } initial_construct
| { attribute_instance } always_construct
| { attribute_instance } combinational_statement
| { attribute_instance } latch_statement
| { attribute_instance } ff_statement
| { attribute_instance } net_alias
| module_common_item
| { attribute_instance } ;

module_root_item ::=
{ attribute_instance } module_instantiation
| { attribute_instance } local_parameter_declaration
| interface_declaration
| program_declaration
| class_declaration
| module_common_item

module_or_generate_item_declaration ::=
net_declaration
| data_declaration
| genvar_declaration
| task_declaration
| function_declaration
| dpi_import_export | extern_constraint_declaration
| extern_method_declaration
| clocking_decl
| template_declaration

non_port_module_item ::=
{ attribute_instance } generated_module_instantiation
| { attribute_instance } local_parameter_declaration
| module_or_generate_item
| { attribute_instance } parameter_declaration ;
| { attribute_instance } specify_block
| { attribute_instance } specparam_declaration
| program_declaration
| class_declaration
| module_declaration

parameter_override ::= defparam list_of_defparam_assignments ;

template_declaration ::= template template_identifier [ ( template_formal_list ) ] ;
{ concurrent_assertion_item }
endtemplate [ : template_identifier ]

template_formal_list ::=
formal_list_item { , formal_list_item }

template_instantiation ::=
template_identifier [ instance_identifier ] [ ( actual_arg_list ) ] ;

bind_directive ::=
bind module_instance_identifier program_instance_identifier ;

A.1.6 Interface items

interface_or_generate_item ::=
{ attribute_instance } continuous_assign
| { attribute_instance } initial_construct
| { attribute_instance } always_construct
| { attribute_instance } combinational_statement
| { attribute_instance } latch_statement
| { attribute_instance } ff_statement
| { attribute_instance } local_parameter_declaration
| { attribute_instance } parameter_declaration ;
| module_common_item
| { attribute_instance } modport_declaration
| { attribute_instance } extern_tf_declaration
| { attribute_instance } ;

extern_tf_declaration ::=
extern method_prototype
| extern forkjoin task named_task_proto ;

interface_item ::=
non_generic_port_declaration ; | non_port_interface_item

non_port_interface_item ::=
{ attribute_instance } generated_interface_instantiation


| { attribute_instance } specparam_declaration
| interface_or_generate_item
| program_declaration
| class_declaration
| interface_declaration

A.1.7 Program items

program_item ::=
port_declaration ;
| non_port_program_item

non_port_program_item ::=
| { attribute_instance } module_or_generate_item_declaration
| { attribute_instance } specparam_declaration
| { attribute_instance } local_parameter_declaration
| { attribute_instance } parameter_declaration ;
| { attribute_instance } initial_construct
| { attribute_instance } concurrent_assertion_item | class_declaration

A.1.8 Class items

class_item ::=
{ attribute_instance } [ rand_property ] [ hiding_property ] data_declaration
| { attribute_instance } { tf_property } task_declaration
| { attribute_instance } { tf_property } function_declaration
| { attribute_instance } { tf_property } method_prototype
| { attribute_instance } constraint_prototype
| { attribute_instance } [ hiding_property ] specparam_declaration
| { attribute_instance } [ hiding_property ] local_parameter_declaration
| { attribute_instance } [ hiding_property ] parameter_declaration ;
| { attribute_instance } [ hiding_property ] constant_property
| { attribute_instance } constraint_declaration

constant_property ::=
const data_type const_identifier [ = constant_expression ] ;

constraint_block ::=
solve variable_identifier { , variable_identifier }
before variable_identifier { , variable_identifier } ;
| constraint_expression dist { { constraint_dist_item { , constraint_dist_item } } ;

constraint_declaration ::=
[ static ] constraint constraint_identifier { { constraint_block } }

constraint_dist_item ::=
range := constraint_expression
| range :/ constraint_expression

constraint_expression ::=
expression | constraint_inside
| ! ( constraint_inside )

constraint_inside ::=
constraint_expression inside { range_list_or_array }

constraint_item ::=
constraint_expression ;
| constraint_expression => constraint_item_or_block
| if ( constraint_expression ) constraint_item_or_block [ else constraint_item_or_block ]

constraint_item_or_block ::=
constraint_item
| { { constraint_item_or_block } }

constraint_prototype ::=
[ static ] constraint constraint_identifier

constraint_range ::=
constraint_expression
| [ constraint_expression : constraint_expression ]

extern_constraint_declaration ::=
[ static ] constraint class_identifier :: constraint_identifier { { constraint_block } }

extern_method_declaration ::=
{ tf_property } function [ automatic ] class_identifier :: function_body_declaration
| { tf_property } task [ automatic ] class_identifier :: task_body_declaration

hiding_property ::=
protected
| private

method_prototype ::=
task named_task_proto ;
| function named_function_proto ;

rand_property ::=
rand
| randc

range_list_or_array ::=
variable_identifier
| constraint_range { , constraint_range }

tf_property ::=
virtual
| hiding_property

A.2 Declarations

A.2.1 Declaration types

A.2.2 Declaration data types

A.2.3 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_modport_port_identifiers ::= port_identifier { , port_identifier }

list_of_net_decl_assignments ::= net_decl_assignment { , net_decl_assignment }

list_of_net_identifiers ::= net_identifier { unpacked_dimension }
{ , net_identifier { unpacked_dimension } }

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_port_identifiers ::= port_identifier { unpacked_dimension } [ = expression ]
{ , port_identifier { unpacked_dimension } [ = expression ] }

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_identifiers_or_assignments ::=
list_of_variable_decl_assignments
| list_of_variable_identifiers

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

A.2.4 Declaration assignments

const_assignment ::= const_identifier = constant_expression

defparam_assignment ::= hierarchical_parameter_identifier = constant_expression

net_decl_assignment ::= net_identifier = expression

param_assignment ::= parameter_identifier = 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 [ = constant_expression ]
| variable_identifier [ ] = new [ constant_expression ] [ ( variable_identifier ) ]
| class_identifier [ parameter_value_assignment ] = new [ ( list_of_arguments ) ]

A.2.5 Declaration ranges

unpacked_dimension ::= [ dimension_constant_expression : dimension_constant_expression ]
| [ dimension_constant_expression ]

packed_dimension 9 ::=
[ dimension_constant_expression : dimension_constant_expression ]
| [ ]

range ::= [ msb_constant_expression : lsb_constant_expression ]

associative_dimension ::=
[ singular_type ]
| [ * ]

variable_dimension ::=
{ unpacked_dimension }
| [ ]
| associative_dimension

dpi_dimension ::=
variable_dimension
| { [ ] }

A.2.6 Function declarations

function_data_type 8 ::= integer_vector_type { packed_dimension } [ range ]
| integer_atom_type
| type_declaration_identifier { packed_dimension }
| non_integer_type
| struct [ packed ] { { struct_union_member } } { packed_dimension }
| union [ packed ] { { struct_union_member } } { packed_dimension }
| enum [ integer_type { packed_dimension } ]
{ enum_identifier [ = constant_expression ] { , enum_identifier [ = constant_expression ] } }
| string
| handle
| void

function_body_declaration ::=
[ signing ] [ range_or_type ]
[ interface_identifier . ] function_identifier ;
{ function_item_declaration }
{ function_statement_or_null }
endfunction [ : function_identifier ]
| [ signing ] [ range_or_type ]
[ interface_identifier . ] function_identifier ( function_port_list ) ;
{ block_item_declaration }
{ function_statement_or_null }
endfunction [ : function_identifier ]

function_declaration ::=
function [ automatic ] function_body_declaration

function_item_declaration ::=
block_item_declaration
| { attribute_instance } tf_input_declaration ; | { attribute_instance } tf_output_declaration ;
| { attribute_instance } tf_inout_declaration ;
| { attribute_instance } tf_ref_declaration ;

function_port_item ::=
{ attribute_instance } tf_input_declaration
| { attribute_instance } tf_output_declaration
| { attribute_instance } tf_inout_declaration
| { attribute_instance } tf_ref_declaration
| { attribute_instance } port_type list_of_tf_port_identifiers | { attribute_instance } tf_data_type list_of_tf_variable_identifiers

function_port_list ::= function_port_item { , function_port_item }

named_function_proto::= function_data_type function_identifier ( list_of_function_proto_formals )

dpi_import_export ::= import "DPI" [ dpi_import_property ] [ c_identifier = ] dpi_function_proto
| export "DPI" [ c_identifier = ] function function_identifier

dpi_import_property ::= context | pure

dpi_function_proto ::=
named_function_proto
| [ signing ] function_data_type function_identifier ( list_of_dpi_proto_formals )

list_of_dpi_proto_formals ::=
[ { attribute_instance } dpi_proto_formal { , { attribute_instance } dpi_proto_formal } ]

dpi_proto_formal ::=
data_type [ port_identifier dpi_dimension { , port_identifier dpi_dimension } ]

list_of_function_proto_formals ::=
[ { attribute_instance } function_proto_formal { , { attribute_instance } function_proto_formal } ]

function_proto_formal ::=
tf_input_declaration
| tf_output_declaration
| tf_inout_declaration
| tf_ref_declaration

range_or_type ::=
{ packed_dimension } range
| function_data_type

A.2.7 Task declarations

task_body_declaration ::=
[ interface_identifier . ] task_identifier ;
{ task_item_declaration }
{ statement_or_null }
endtask [ : task_identifier ]
| [ interface_identifier . ] task_identifier ( task_port_list ) ;
{ block_item_declaration }
{ statement_or_null }
endtask [ : task_identifier ]

task_declaration ::= task [ automatic ] task_body_declaration

task_item_declaration ::=
block_item_declaration
| { attribute_instance } tf_input_declaration ;
| { attribute_instance } tf_output_declaration ;
| { attribute_instance } tf_inout_declaration ;
| { attribute_instance } tf_ref_declaration ;

task_port_list ::= task_port_item { , task_port_item }
| list_of_port_identifiers { , task_port_item }

task_port_item ::=
{ attribute_instance } tf_input_declaration
| { attribute_instance } tf_output_declaration
| { attribute_instance } tf_inout_declaration
| { attribute_instance } tf_ref_declaration ;
| { attribute_instance } port_type list_of_tf_port_identifiers | { attribute_instance } tf_data_type list_of_tf_variable_identifiers

tf_input_declaration ::=
input port_type list_of_tf_port_identifiers
| input tf_data_type list_of_tf_variable_identifiers

tf_output_declaration ::=
output [ signing ] { packed_dimension } range list_of_tf_port_identifiers
| output tf_data_type list_of_tf_variable_identifiers

tf_inout_declaration ::=
inout [ signing ] { packed_dimension } range list_of_tf_port_identifiers
| inout tf_data_type list_of_tf_variable_identifiers

tf_ref_declaration ::=
ref data_type list_of_tf_variable_identifiers

tf_data_type ::=
data_type
| handle

named_task_proto ::= task_identifier ( task_proto_formal { , task_proto_formal } )

task_proto_formal ::=
tf_input_declaration
| tf_output_declaration
| tf_inout_declaration
| tf_ref_declaration

A.2.8 Block item declarations

block_item_declaration ::=
{ attribute_instance } block_data_declaration
| { attribute_instance } local_parameter_declaration
| { attribute_instance } parameter_declaration ;

A.2.9 Interface declarations

modport_declaration ::= modport modport_item { , modport_item } ;

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

modport_ports_declaration ::=
modport_simple_ports_declaration
| modport_hierarchical_ports_declaration
| modport_tf_ports_declaration

modport_simple_ports_declaration ::=
input list_of_modport_port_identifiers
| output list_of_modport_port_identifiers
| inout list_of_modport_port_identifiers
| ref [ data_type ] list_of_modport_port_identifiers

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

modport_tf_ports_declaration ::=
import_export modport_tf_port

modport_tf_port ::=
task named_task_proto { , named_task_proto }
| function named_function_proto { , named_function_proto }
| task_or_function_identifier { , task_or_function_identifier }

import_export ::= import | export

A.2.10 Assertion declarations

concurrent_assertion_item ::= | property_declaration
| sequence_declaration
| concurrent_assert_statement
| concurrent_cover_statement

property_declaration ::=
property property_identifier [ property_formal_list ] ;
{ variable_declaration }
{ sequence_declaration }
property_spec ;
endproperty [ : property_identifier ]

property_formal_list ::=
( formal_list_item { , formal_list_item } )

property_modifier ::=
disable iff ( expression ) [ not ]
| [ disable iff ( expression ) ] not

property_spec ::=
[ event_control ] property_modifier property_expr
| property_expr

property_expr ::=
sequence_spec
| property_implication

property_implication ::=
sequence_expr |-> [ not ] sequence_expr
| clocked_sequence |-> [ not ] sequence_expr
| sequence_expr |=> [ not ] sequence_expr
| clocked_sequence |=> [ not ] sequence_expr
| multi_clock_sequence |=> [ not ] multi_clock_sequence

sequence_declaration ::=
sequence sequence_identifier [ sequence_formal_list ] ;
{variable_declaration }
{ sequence_declaration }
sequence_spec ;
endsequence [ : sequence_identifier ]

sequence_formal_list ::=
( formal_list_item { , formal_list_item } )

sequence_spec ::=
multi_clock_sequence
| sequence_expr

multi_clock_sequence::=
clocked_sequence { ## clocked_sequence }

clocked_sequence ::=
event_control sequence_expr

cycle_delay_range ::=
## constant_expression
| ## [ const_or_range_expression ]

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

sequence_instance ::=
sequence_identifier [ ( actual_arg_list ) ]

formal_list_item ::=
formal_identifier [ = actual_arg_expr ]

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 ::=
repeat_operator
| nth_event_operator
| counting_operator

sequence_abbrev ::= repeat_operator

repeat_operator ::= [* const_or_range_expression ]

counting_operator ::= [*= const_or_range_expression ]

nth_event_operator ::= [*> const_or_range_expression ]

const_or_range_expression ::=
constant_expression
| const_range_expression

const_range_expression ::=
constant_expression : constant_expression
| constant_expression : $

A.3 Primitive instances

A.3.1 Primitive instantiation and instances

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_gate_instance ] ( output_terminal , input_terminal ,
ncontrol_terminal , pcontrol_terminal )

enable_gate_instance ::= [ name_of_gate_instance ] ( output_terminal , input_terminal , enable_terminal )

mos_switch_instance ::= [ name_of_gate_instance ] ( output_terminal , input_terminal , enable_terminal )

n_input_gate_instance ::= [ name_of_gate_instance ] ( output_terminal , input_terminal { , input_terminal } )

n_output_gate_instance ::= [ name_of_gate_instance ] ( output_terminal { , output_terminal } ,
input_terminal )

pass_switch_instance ::= [ name_of_gate_instance ] ( inout_terminal , inout_terminal )

pass_enable_switch_instance ::= [ name_of_gate_instance ] ( inout_terminal , inout_terminal ,
enable_terminal )

pull_gate_instance ::= [ name_of_gate_instance ] ( output_terminal )

name_of_gate_instance ::= gate_instance_identifier { range }

A.3.2 Primitive strengths

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

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

A.3.3 Primitive terminals

enable_terminal ::= expression

inout_terminal ::= net_lvalue

input_terminal ::= expression

ncontrol_terminal ::= expression

output_terminal ::= net_lvalue

pcontrol_terminal ::= expression

A.3.4 Primitive gate and switch types

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

A.4 Module, interface and generated instantiation

A.4.1 Instantiation

A.4.2 Generated instantiation

A.5 UDP declaration and instantiation

A.5.1 UDP declaration

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_declaration ::=
{ attribute_instance } primitive udp_identifier ( udp_port_list ) ;
udp_port_declaration { udp_port_declaration }
udp_body
endprimitive
| { attribute_instance } primitive udp_identifier ( udp_declaration_port_list ) ;
udp_body
endprimitive

A.5.2 UDP ports

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

A.5.3 UDP body

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 | *

A.5.4 UDP instantiation

udp_instantiation ::= udp_identifier [ drive_strength ] [ delay2 ] udp_instance { , udp_instance } ;

udp_instance ::= [ name_of_udp_instance ] { range } ( output_terminal , input_terminal { , input_terminal } )

name_of_udp_instance ::= udp_instance_identifier { range }

A.6 Behavioral statements

A.6.1 Continuous assignment and net alias statements

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 expression = expression ;

net_assignment ::= net_lvalue = expression

A.6.2 Procedural blocks and assignments

initial_construct ::= initial statement_or_null

always_construct ::= always statement_or_null

combinational_statement ::= always_comb statement_or_null

latch_statement ::= always_latch statement_or_null

ff_statement ::= always_ff statement_or_null

blocking_assignment ::=
variable_lvalue = delay_or_event_control expression
| hierarchical_variable_identifier = new [ constant_expression ] [ ( variable_identifier ) ]
| class_identifier [ parameter_value_assignment ] = new [ ( list_of_arguments ) ]
| class_identifier . randomize [ ( ) ] with constraint_block ;
| operator_assignment

operator_assignment ::= variable_lvalue assignment_operator expression

assignment_operator ::=
= | += | -= | *= | /= | %= | &= | |= | ^= | <<= | >>= | <<<= | >>>=

nonblocking_assignment ::= variable_lvalue <= [ delay_or_event_control ] expression

procedural_continuous_assignments ::=
assign variable_assignment
| deassign variable_lvalue
| force variable_assignment
| force net_assignment
| release variable_lvalue
| release net_lvalue

function_blocking_assignment ::= variable_lvalue = expression

function_statement_or_null ::=
function_statement
| { attribute_instance } ;

variable_assignment ::= operator_assignment
| inc_or_dec_expression

A.6.3 Parallel and sequential blocks

action_block ::= [ statement ] [ else statement ] ;

function_seq_block ::=
begin [ : block_identifier { block_item_declaration } ] { function_statement_or_null }
end [ : block_identifier ]

join_keyword ::= join | join_any | join_none

par_block ::=
fork [ : block_identifier ] { block_item_declaration } { statement_or_null } join_keyword [ : block_identifier ]

seq_block ::=
begin [ : block_identifier ] { block_item_declaration } { statement_or_null }
end [ : block_identifier ]

A.6.4 Statements

statement ::= [ block_identifier : ] statement_item

statement_item ::=
{ attribute_instance } blocking_assignment ;
| { attribute_instance } nonblocking_assignment ;
| { attribute_instance } procedural_continuous_assignments ;
| { attribute_instance } case_statement
| { attribute_instance } conditional_statement
| { attribute_instance } inc_or_dec_expression ;
| { attribute_instance } function_call ; | { attribute_instance } disable_statement
| { attribute_instance } event_trigger
| { attribute_instance } loop_statement
| { attribute_instance } jump_statement
| { attribute_instance } par_block
| { attribute_instance } procedural_timing_control_statement
| { attribute_instance } seq_block
| { attribute_instance } system_task_enable
| { attribute_instance } task_enable
| { attribute_instance } wait_statement
| { attribute_instance } procedural_assertion_items

statement_or_null ::=
statement
| { attribute_instance } ;

function_statement ::= [ block_identifier : ] function_statement_item

function_statement_item ::=
{ attribute_instance } function_blocking_assignment ;
| { attribute_instance } function_case_statement
| { attribute_instance } function_conditional_statement
| { attribute_instance } inc_or_dec_expression ;
| { attribute_instance } function_call ; | { attribute_instance } function_loop_statement
| { attribute_instance } jump_statement
| { attribute_instance } function_seq_block
| { attribute_instance } disable_statement
| { attribute_instance } system_task_enable

A.6.5 Timing control statements

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 ::=
@ event_identifier
| @ ( event_expression )
| @*
| @ (*)

event_expression ::=
[ edge_identifier ] expression [ iff expression ] | event_expression or event_expression
| event_expression , event_expression

procedural_timing_control ::= delay_control
| event_control

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 ;

A.6.6 Conditional statements

conditional_statement ::=
[ unique_priority ] if ( expression ) statement_or_null [ else statement_or_null ]
| if_else_if_statement

if_else_if_statement ::=
[ unique_priority ] if ( expression ) statement_or_null
{ else [ unique_priority ] if ( expression ) statement_or_null }
[ else statement_or_null ]

function_conditional_statement ::=
[ unique_priority ] if ( expression ) function_statement_or_null [ else function_statement_or_null ]
| function_if_else_if_statement

function_if_else_if_statement ::=
[ unique_priority ] if ( expression ) function_statement_or_null
{ else [ unique_priority ] if ( expression ) function_statement_or_null }
[ else function_statement_or_null ]

unique_priority ::= unique | priority

A.6.7 Case statements

case_statement ::=
[ unique_priority ] case ( expression ) case_item { case_item } endcase
| [ unique_priority ] casez ( expression ) case_item { case_item } endcase
| [ unique_priority ] casex ( expression ) case_item { case_item } endcase

case_item ::=
expression { , expression } : statement_or_null
| default [ : ] statement_or_null

function_case_statement ::=
[ unique_priority ] case ( expression ) function_case_item { function_case_item } endcase
| [ unique_priority ] casez ( expression ) function_case_item { function_case_item } endcase
| [ unique_priority ] casex ( expression ) function_case_item { function_case_item } endcase

function_case_item ::=
expression { , expression } : function_statement_or_null
| default [ : ] function_statement_or_null

A.6.8 Looping statements

function_loop_statement ::=
forever function_statement_or_null
| repeat ( expression ) function_statement_or_null
| while ( expression ) function_statement_or_null
| for ( variable_decl_or_assignment ; expression ; variable_assignment )
function_statement_or_null
| do function_statement_or_null while ( expression ) ;

loop_statement ::=
forever statement_or_null
| repeat ( expression ) statement_or_null
| while ( expression ) statement_or_null
| for ( variable_decl_or_assignment ; expression ; variable_assignment ) statement_or_null
| do statement_or_null while ( expression ) ;

variable_decl_or_assignment ::=
data_type list_of_variable_identifiers_or_assignments | variable_assignment

A.6.9 Task enable statements

system_task_enable ::= system_task_identifier [ ( [ expression ] { , [ expression ] } ) ] ;

task_enable ::= hierarchical_task_identifier [ ( list_of_arguments ) ] ;

A.6.10 Assertion statements

procedural_assertion_items ::= concurrent_assert_statement
| concurrent_cover_statement
| immediate_assert_statement

immediate_assert_statement ::=
assert ( expression ) action_block

concurrent_assert_statement ::=
assert property ( property_spec ) action_block

concurrent_cover_statement ::=
cover property ( property_instance ) statement_or_null

property_instance::=
property_identifier [ ( actual_arg_list ) ]

A.6.11 Clocking Domain

clocking_decl ::= [ default ] clocking [ clocking_identifier ] clocking_event ;
{ clocking_item }
endclocking

clocking_event ::=
@ identifier
| @ ( event_expression )

clocking_item :=
default default_skew ;
| clocking_direction list_of_clocking_decl_assign ;

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 [ = hierarchical_identifier ]

clocking_skew ::=
edge_identifier [ delay_control ]
| delay_control

A.7 Specify section

A.7.1 Specify block declaration

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 ;

A.7.2 Specify path declarations

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 }

A.7.3 Specify block terminals

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

output_identifier ::= output_port_identifier | inout_port_identifier

A.7.4 Specify path delays

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 =>
specify_output_terminal_descriptor [ polarity_operator ] : data_source_expression )

full_edge_sensitive_path_description ::=
( [ edge_identifier ] list_of_path_inputs *>
list_of_path_outputs [ polarity_operator ] : data_source_expression )

data_source_expression ::= expression

edge_identifier ::= posedge | negedge

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 ::= + | -

A.7.5 System timing checks

A.8 Expressions

A.8.1 Concatenations

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 ::= { constant_expression concatenation }

A.8.2 Function calls

constant_function_call ::= function_identifier { attribute_instance }
[ ( list_of_constant_arguments ) ]

function_call ::= hierarchical_function_identifier { attribute_instance } [ ( list_of_arguments ) ]

list_of_arguments ::=
[ expression ] { , [ expression ] }
| . identifier ( [ expression ] ) { , . identifier ( [ expression ] ) }

list_of_constant_arguments ::=
[ constant_expression ] { , [ constant_expression ] }
| . identifier ( [ constant_expression ] ) { , . identifier ( [ constant_expression ] ) }

system_function_call ::= system_function_identifier [ ( expression { , expression } ) ]

A.8.3 Expressions

base_expression ::= expression

inc_or_dec_expression ::=
inc_or_dec_operator { attribute_instance } variable_lvalue | variable_lvalue { attribute_instance } inc_or_dec_operator

conditional_expression ::= expression1 ? { attribute_instance } expression2 : expression3

constant_base_expression ::= constant_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
| string_literal

constant_mintypmax_expression ::=
constant_expression
| constant_expression : constant_expression : constant_expression

constant_param_expression ::=
constant_expression

constant_range_expression ::=
constant_expression
| msb_constant_expression : lsb_constant_expression
| constant_base_expression +: width_constant_expression
| constant_base_expression -: width_constant_expression

dimension_constant_expression ::= constant_expression

expression1 ::= expression

expression2 ::= expression

expression3 ::= expression

expression ::=
primary
| unary_operator { attribute_instance } primary
| inc_or_dec_expression | ( operator_assignment )
| expression binary_operator { attribute_instance } expression
| conditional_expression
| string_literal

lsb_constant_expression ::= constant_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

msb_constant_expression ::= constant_expression

range_expression ::=
expression
| msb_constant_expression : lsb_constant_expression
| base_expression +: width_constant_expression
| base_expression -: width_constant_expression

width_constant_expression ::= constant_expression

A.8.4 Primaries

constant_primary ::=
constant_concatenation
| constant_function_call
| ( constant_mintypmax_expression )
| constant_multiple_concatenation
| genvar_identifier
| number
| parameter_identifier
| specparam_identifier
| time_literal
| '0 | '1 | 'z | 'Z | 'x | 'X

module_path_primary ::=
number
| identifier
| module_path_concatenation
| module_path_multiple_concatenation
| function_call
| system_function_call
| constant_function_call
| ( module_path_mintypmax_expression )

primary ::=
number
| hierarchical_identifier { [ expression ] } [ [ range_expression ] ] [ . method_identifier { attribute_instance } [ ( expression { , expression } ) ] ] | concatenation
| multiple_concatenation
| function_call
| system_function_call
| constant_function_call
| ( mintypmax_expression )
| casting_type ' ( expression )
| void ' ( function_call )
| casting_type ' { expression { , expression } }
| casting_type ' { expression { expression } }
| time_literal
| '0 | '1 | 'z | 'Z | 'x | 'X
| null

time_literal 7 ::=
unsigned_number time_unit
| fixed_point_number time_unit

time_unit ::= s | ms | us | ns | ps | fs

A.8.5 Expression left-side values

net_lvalue ::=
hierarchical_net_identifier { [ constant_expression ] } [ [ constant_range_expression ] ]
| { net_lvalue { , net_lvalue } }

variable_lvalue ::=
hierarchical_variable_identifier { [ expression ] } [ [ range_expression ] ]
| { variable_lvalue { , variable_lvalue } }

A.8.6 Operators

unary_operator ::=
+ | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~

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

inc_or_dec_operator ::= ++ | --

unary_module_path_operator ::=

! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~

binary_module_path_operator ::=

== | != | && | || | & | | | ^ | ^~ | ~^

A.8.7 Numbers

number ::=
decimal_number
| octal_number
| binary_number
| hex_number
| real_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 1 ::= non_zero_decimal_digit { _ | decimal_digit}

real_number 1 ::=
fixed_point_number
| unsigned_number [ . unsigned_number ] exp [ sign ] unsigned_number

fixed_point_number 1 ::= unsigned_number . unsigned_number

exp ::= e | E

unsigned_number 1 ::= decimal_digit { _ | decimal_digit }

binary_value 1 ::= binary_digit { _ | binary_digit }

octal_value 1 ::= octal_digit { _ | octal_digit }

hex_value 1 ::= hex_digit { _ | hex_digit }

decimal_base 1 ::= ' [ s | S ] d | ' [ s | S ] D

binary_base 1 ::= ' [ s | S ] b | ' [ s | S ] B

octal_base 1 ::= ' [ s | S ] o | ' [ s | S ] O

hex_base 1 ::= ' [ 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 | ?

A.8.8 Strings

string_literal ::= " { Any_ASCII_Characters } "

A.9 General

A.9.1 Attributes

attribute_instance ::= (* attr_spec { , attr_spec } *)

attr_spec ::=
attr_name = constant_expression
| attr_name

attr_name ::= identifier

A.9.2 Comments

comment ::=
one_line_comment
| block_comment

one_line_comment ::= // comment_text \n

block_comment ::= /* comment_text */

comment_text ::= { Any_ASCII_character }

A.9.3 Identifiers

block_identifier ::= identifier

c_identifier 2 ::= [ a - zA - Z_ ] { [ a - zA - Z0 - 9_ ] }

cell_identifier ::= identifier

class_identifier ::= identifier

clocking_identifier ::= identifier

config_identifier ::= identifier

constraint_identifier ::= identifier

const_identifier ::= identifier

enum_identifier ::= identifier

escaped_hierarchical_identifier 4 ::=
escaped_hierarchical_branch { . simple_hierarchical_branch | . escaped_hierarchical_branch }

escaped_identifier ::= \ {any_ASCII_character_except_white_space} white_space

event_identifier ::= identifier

formal_identifier ::= identifier

function_identifier ::= identifier

gate_instance_identifier ::= identifier

generate_block_identifier ::= identifier

genvar_identifier ::= identifier

hierarchical_block_identifier ::= hierarchical_identifier

hierarchical_event_identifier ::= hierarchical_identifier

hierarchical_function_identifier ::= hierarchical_identifier

hierarchical_identifier ::=
simple_hierarchical_identifier
| escaped_hierarchical_identifier

hierarchical_parameter_identifier ::= hierarchical_identifier

hierarchical_net_identifier ::= hierarchical_identifier

hierarchical_variable_identifier ::= hierarchical_identifier

hierarchical_task_identifier ::= hierarchical_identifier

identifier ::=
simple_identifier
| escaped_identifier

interface_identifier ::= identifier

interface_instance_identifier ::= identifier

inout_port_identifier ::= identifier

input_port_identifier ::= identifier

instance_identifier ::= identifier

library_identifier ::= identifier

method_identifier ::= identifier

modport_identifier ::= identifier

module_identifier ::= identifier

module_instance_identifier ::= identifier

net_identifier ::= identifier

output_port_identifier ::= identifier

parameter_identifier ::= identifier

port_identifier ::= identifier

program_identifier ::= identifier

program_instance_identifier ::= identifier

property_identifier ::= identifier

real_identifier ::= identifier

sequence_identifier ::= identifier

signal_identifier ::= identifier

simple_hierarchical_identifier 3 ::= simple_hierarchical_branch [ . escaped_identifier ]

simple_identifier 2 ::= [ a - zA - Z_ ] { [ a - zA - Z0 - 9_$ ] }

specparam_identifier ::= identifier

state_identifier ::= identifier

system_function_identifier 5 ::= $ [ a - zA - Z0 - 9_$ ]{ [ a - zA - Z0 - 9_$ ] }

system_task_identifier 5 ::= $ [ a - zA - Z0 - 9_$ ]{ [ a - zA - Z0 - 9_$ ] }

task_or_function_identifier ::= task_identifier | function_identifier

task_identifier ::= identifier

template_identifier ::= identifier

terminal_identifier ::= identifier

text_macro_identifier ::= simple_identifier

topmodule_identifier ::= identifier

type_declaration_identifier ::= type_identifier { unpacked_dimension }

type_identifier ::= identifier

udp_identifier ::= identifier

udp_instance_identifier ::= identifier

variable_identifier ::= identifier

A.9.4 Identifier branches

simple_hierarchical_branch 3 ::=
simple_identifier { [ unsigned_number ] } [ { . simple_identifier { [ unsigned_number ] } } ]

escaped_hierarchical_branch 4 ::=
escaped_identifier { [ unsigned_number ] } [ { . escaped_identifier { [ unsigned_number ] } } ]

A.9.5 White space

white_space ::= space | tab | newline | eof 6