SystemVerilog BNF (1364-2001 bnf merged with SV draft3 bnf)

Annex A
Formal syntax definition
(normative)
The formal syntax of Verilog HDL is described using Backus-Naur Form (BNF).

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 ::=  [unit] [precision]  { description }
description ::=
          module_declaration
        | udp_declaration
        | module_root_item
        | statement
module_declaration ::=
          { attribute_instance } module_keyword module_identifier [ parameter_port_list ]
                  [ list_of_ports ] ;  [unit] [precision]  { module_item }
                  endmodule
        | { attribute_instance } module_keyword module_identifier [ parameter_port_list ]
                  [ list_of_port_declarations ] ;  [unit] [precision]
                  { non_port_module_item }
                  endmodule
module_keyword ::= module | macromodule
interface_declaration ::=
          { attribute_instance } interface interface_identifier [ parameter_port_list ]
                  [ list_of_ports ] ; [unit] [precision] { interface_item }
                  endinterface [: interface_identifier]
        | { attribute_instance } interface interface_identifier [ parameter_port_list ]
                [ list_of_port_declarations ] ; [unit] [precision]
                { non_port_interface_item }
                endinterface [: interface_identifier]
unit ::= [ timeunit [ time_literal ] ; ]
precision ::= [ timeprecision [ 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 } )
        | ( )
port ::=
          [ port_expression ]
        | . port_identifier ( [ port_expression ] )
port_expression ::=
          port_reference
        | { port_reference { , port_reference } }
port_reference ::=
          port_identifier
        | port_identifier [ constant_expression ]
        | port_identifier [ range_expression ]
port_declaration ::=
          { attribute_instance } inout_declaration
        | { attribute_instance } input_declaration
        | { attribute_instance } output_declaration
        | { attribute_instance } interface_port_declaration

A.1.5 Module items

A.1.6 Interface items

A.2 Declarations

A.2.1 Declaration types

A.2.1.1 Module parameter declarations

local_parameter_declaration ::=
          localparam [ signing ] { packed_dimension } [ range ] list_of_param_assignments ;
        | localparam integer list_of_param_assignments ;
        | localparam real list_of_param_assignments ;
        | localparam realtime list_of_param_assignments ;
        | localparam time list_of_param_assignments ;
        | localparam data_type list_of_param_assignments ;
parameter_declaration ::=
          parameter [ signing ] { packed_dimension } [ range ] list_of_param_assignments ;
        | parameter integer list_of_param_assignments ;
        | parameter real list_of_param_assignments ;
        | parameter realtime list_of_param_assignments ;
        | parameter time list_of_param_assignments ;
        | parameter data_type list_of_param_assignments ;
        | parameter type list_of_type_assignments ;
specparam_declaration ::=
specparam [ range ] list_of_specparam_assignments ;

A.2.1.2 Port declarations

inout_declaration ::= inout [ net_type ] [ signed ] [ range ] list_of_port_identifiers
inout_declaration ::= inout [ port_type ] list_of_port_identifiers
        | inout . port_identifier ( [ port_expression ] )

input_declaration ::= input [ net_type ] [ signed ] [ range ]
                  list_of_port_identifiers
input_declaration ::= input [ port_type ] list_of_port_identifiers
        | input . port_identifier ( [ port_expression ] )
output_declaration ::=
          output [ net_type ] [ signed ] [ range ]
                  list_of_port_identifiers
        | output [ reg ] [ signed ] [ range ]
                  list_of_port_identifiers
        | output reg [ signed ] [ range ]
                  list_of_variable_port_identifiers
        | output [ output_variable_type ]
                  list_of_port_identifiers
        | output output_variable_type
                  list_of_variable_port_identifiers
          output [ port_type ] list_of_port_identifiers
        | output . port_identifier ( [ port_expression ] )
        | output data_type list_of_variable_port_identifiers
interface_port_declaration ::=
          interface list_of_interface_identifiers
        | interface . modport_identifier list_of_interface_identifiers
        | identifier list_of_interface_identifiers
        | identifier . modport_identifier list_of_interface_identifiers

A.2.1.3 Type declarations

block_data_declaration ::=
          block_variable_declaration
        | constant_declaration
        | type_declaration
        | state_declaration
constant_declaration ::= const data_type const_assignment ;
data_declaration ::=
          variable_declaration
        | constant_declaration
        | type_declaration
        | state_declaration
event_declaration ::= event list_of_event_identifiers ;
genvar_declaration ::= genvar list_of_genvar_identifiers ;
integer_declaration ::= integer list_of_variable_identifiers ;
net_declaration ::=
          net_type [ signing ]
                  [ delay3 ] list_of_net_identifiers ;
        | net_type [ drive_strength ] [ signing ]
                  [ delay3 ] list_of_net_decl_assignments ;
        | net_type [ vectored | scalared ] [ signing ]
                  { packed_dimension } range [ delay3 ] list_of_net_identifiers ;
        | net_type [ drive_strength ] [ vectored | scalared ] [ signing ]
                  { packed_dimension } range [ delay3 ] list_of_net_decl_assignments ;
        | trireg [ charge_strength ] [ signing ]
                  [ delay3 ] list_of_net_identifiers ;
        | trireg [ drive_strength ] [ signing ]
                  [ delay3 ] list_of_net_decl_assignments ;
        | trireg [ charge_strength ] [ vectored | scalared ] [ signing ]
                  { packed_dimension } range [ delay3 ] list_of_net_identifiers ;
        | trireg [ drive_strength ] [ vectored | scalared ] [ signing ]
                  { packed_dimension } range [ delay3 ] list_of_net_decl_assignments ;
real_declaration ::= real list_of_real_identifiers ;
realtime_declaration ::= realtime list_of_real_identifiers ;
reg_declaration ::= reg [ signing ] [ range ]
                  list_of_variable_identifiers ;
state_declaration ::= state { state_list } state_identifier [ delay_or_event_control ] ;
state_list ::= and_states | or_states
and_states ::= state and state { and state }
or_states ::= state , state { , state }
state ::= [ { state_list } ] state_identifier
time_declaration ::= time list_of_variable_identifiers ;
type_declaration ::=
          typedef data_type type_declaration_identifier ;
        | typedef interface_identifier { [ constant_expression ] } . type_identifier
                type_declaration_identifier ;
block_variable_declaration ::=
          [ lifetime ] data_type list_of_variable_identifiers ;
        | lifetime data_type list_of_variable_decl_assignments ;
variable_declaration ::=
          [ lifetime ] data_type list_of_variable_identifiers_or_assignments ;
lifetime ::= static | automatic

A.2.2 Declaration data types

A.2.2.1 Net and variable types

output_variable_type ::= integer | time
real_type ::=
          real_identifier [ = constant_expression ]
        | real_identifier dimension { dimension }
variable_type ::=
          variable_identifier [ = constant_expression ]
        | variable_identifier dimension { dimension }
data_type ::=
          integer_vector_type [ signing ] { packed_dimension } [ range ]
        | integer_atom_type [ signing ] { packed_dimension }
        | type_declaration_identifier
        | non_integer_type
        | struct { { struct_union_member } }
        | union { { struct_union_member } }
        | enum { enum_identifier [ = constant_expression ]
                { , enum_identifier [ = constant_expression ] } }
        | void
integer_atom_type ::= byte | char | shortint | int | longint | integer
integer_type ::= integer_vector_type | integer_atom_type
integer_vector_type ::= bit | logic | reg
net_type ::=
          supply0 | supply1
        | tri           | triand  | trior | tri0 | tri1
        | wire          | wand   | wor
non_integer_type ::= time | shortreal | real | realtime | $built-in
port_type ::=
          data_type { packed_dimension }
        | net_type [ signing ] { packed_dimension }
        | trireg [ signing ] { packed_dimension }
        | event
/* SB - IMPLICIT PORT TYPE
        following was not in SV d3, but is part of 1364-2001 as
        explicit parts of input, output and inout. I've extended
        the single dimension of 1364-2001 to support SV array
        passing
        4/1/02 - It was noted during the HDLCon review that this
        only holds true for for modules, but not for tasks and
        functions. I believe that is incorrect. The following
        production allows:
           module foo(input [3:0] xxx);
        or
           task foo(input [3:0] xxx);
        or
           function [3:0] foo(input [3:0] xxx);

        ... which all should be allowed.
         */
        | [ signing ] { packed_dimension } range
signing ::= [ signed ] | [ unsigned ]
simple_type ::= integer_type | non_integer_type | type_identifier
struct_union_member ::= data_type list_of_variable_identifiers_or_assignments ;

A.2.2.2 Strengths

A.2.2.3 Delays

A.2.3 Declaration lists

A.2.4 Declaration assignments

const_assignment ::= const_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

A.2.5 Declaration ranges

unpacked_dimension ::= [ dimension_constant_expression : dimension_constant_expression ]
packed_dimension ::= [ dimension_constant_expression : dimension_constant_expression ]
range ::= [ msb_constant_expression : lsb_constant_expression ]

A.2.6 Function declarations

function_declaration ::=
            function [ automatic ] [ signing ] [ range_or_type ]
                  [ interface_identifier . ] function_identifier ;
            function_item_declaration { function_item_declaration }
            { function_statement }
            endfunction [ : function_identifier ]
           | function [ automatic ] [ signing ] [ range_or_type ]
                  [ interface_identifier . ] function_identifier ( function_port_list ) ;
            block_item_declaration { block_item_declaration }
            { function_statement }
            endfunction [ : function_identifier ]
function_item_declaration ::=
          block_item_declaration
        | { attribute_instance } input_declaration ;
        | { attribute_instance } output_declaration ;
        | { attribute_instance } inout_declaration ;
function_port_item ::=
          { attribute_instance } input_declaration
        | { attribute_instance } output_declaration
        | { attribute_instance } inout_declaration
function_port_list ::= function_port_item { , function_port_item }
function_port_list ::= { attribute_instance } input_declaration { , { attribute_instance } input_declaration }
range_or_type ::= range | integer | real | realtime | time
function_prototype ::= function data_type ( list_of_function_proto_formals )
named_function_proto ::= function data_type function_identifier ( list_of_function_proto_formals )
list_of_function_proto_formals ::=
          [ { attribute_instance } function_proto_formal { ,
                { attribute_instance } function_proto_formal } ]
function_proto_formal ::=
          input data_type [ variable_declaration_identifier ]
        | inout data_type [ variable_declaration_identifier ]
        | output data_type [ variable_declaration_identifier ]
        | variable_declaration_identifier
range_or_type ::=
          { packed_dimension } range
        | data_type

A.2.7 Task declarations

task_declaration ::=
            task [ automatic ] [ interface_identifier . ] task_identifier ;
            { task_item_declaration }
            { statement }
            endtask [ : task_identifier ]
          | task [ automatic ] [ interface_identifier . ] task_identifier ( task_port_list ) ;
            { block_item_declaration }
            { statement }
            endtask [ : task_identifier ]
task_item_declaration ::=
          block_item_declaration
        | { attribute_instance } input_declaration ;
        | { attribute_instance } output_declaration ;
        | { attribute_instance } inout_declaration ;
task_port_list ::= task_port_item { , task_port_item }
task_port_item ::=
          { attribute_instance } input_declaration
        | { attribute_instance } output_declaration
        | { attribute_instance } inout_declaration
task_prototype ::=
          task ( { attribute_instance } task_proto_formal
                { , { attribute_instance } task_proto_formal } )
named_task_proto ::= task task_identifier ( task_proto_formal { , task_proto_formal } )
task_proto_formal ::=
          [ port ] input data_type [ variable_declaration_identifier ]
        | [ port ] inout data_type [ variable_declaration_identifier ]
        | [ port ] output data_type [ variable_declaration_identifier ]
        | port event variable

A.2.8 Block item declarations

block_item_declaration ::=
          { attribute_instance } block_reg_declaration
          { attribute_instance } block_data_declaration
        | { attribute_instance } event_declaration
        | { attribute_instance } integer_declaration
        | { attribute_instance } local_parameter_declaration
        | { attribute_instance } parameter_declaration
        | { attribute_instance } real_declaration
        | { attribute_instance } realtime_declaration
        | { attribute_instance } time_declaration
block_reg_declaration ::= reg [ signing ] [ range ]
                  list_of_block_variable_identifiers ;
list_of_block_variable_identifiers ::=
                  block_variable_type { , block_variable_type }
block_variable_type ::=
          variable_identifier
        | variable_identifier dimension { dimension }

A.2.9 Interface declarations

modport_declaration ::= modport list_of_modport_identifiers ;
list_of_modport_identifiers ::= modport_item { , modport_item }
modport_item ::= modport_identifier ( modport_port { , modport_port } )
modport_port ::=
          input  [port_type] port_identifier
        | output [port_type] port_identifier
        | inout  [port_type] port_identifier
        | interface_identifier . port_identifier
        | import_export task named_task_proto
        | import_export function named_fn_proto
/* SB - The bnf Peter sent also included this:
        | import_export identifier { , identifier }
    but it must not be part of SystemVerilog, or
    he will need to include descriptive text for
    the document (i.e. what kind of identifiers
    are these and what does it do?)

*/
import_export ::= import | export

A.3 Primitive instances

A.3.1 Primitive instantiation and instances

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

A.4 Module, interface and generated instantiation

A.4.1 Instantiation

A.4.1.1 Module instantiation

A.4.1.2 Interface instantiation

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

A.4.2 Generated instantiation

A.4.2.1 Generated module instantiation

generated_module_instantiation ::= generate { generate_module_item } endgenerate
generate_module_item_or_null ::= generate_module_item | ;
generate_module_item ::=
          generate_module_conditional_statement
        | generate_module_case_statement
        | generate_module_loop_statement
        | generate_module_block
        | module_or_generate_item
generate_module_conditional_statement ::=
          if ( constant_expression ) generate_module_item_or_null
          [ else generate_module_item_or_null ]
generate_module_case_statement ::=
          case ( constant_expression )
          genvar_module_case_item { genvar_module_case_item }
          endcase
genvar_module_case_item ::=
          constant_expression  { , constant_expression } : generate_module_item_or_null
          | default [ : ] generate_module_item_or_null
generate_module_loop_statement ::=
          for ( genvar_decl_assignment ; constant_expression ; genvar_assignment )
          begin : generate_block_identifier { generate_module_item } end
          generate_module_named_block
genvar_assignment ::=
          genvar_identifier = constant_expression
        | genvar_identifier assignment_operator constant_expression
        | inc_or_dec_operator genvar_identifier
        | genvar_identifier inc_or_dec_operator
genvar_decl_assignment ::=
          [ genvar ] genvar_identifier = constant_expression
generate_module_named_block ::=
          begin : generate_block_identifier { generate_module_item } end
        | generate_block_identifier : generate_module_block
generate_module_block ::=
          begin [ : generate_block_identifier ]
          { generate_module_item }
          end [ : generate_block_identifier ]

A.4.2.2 Generated interface instantiation

A.5 UDP declaration and instantiation

A.5.1 UDP declaration

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 statements

continuous_assign ::= assign [ drive_strength ] [ delay3 ] list_of_net_assignments ;
list_of_net_assignments ::= net_assignment { , net_assignment }
net_assignment ::= net_lvalue = expression

A.6.2 Procedural blocks and assignments

initial_construct ::= initial statement
always_construct ::= always statement
combinational_statement ::= always_comb statement
latch_statement ::= always_latch statement
ff_statement ::= always_ff statement
blocking_assignment ::=
          variable_lvalue = [ delay_or_event_control ] expression
        | 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 } ;

A.6.3 Parallel and sequential blocks

function_seq_block ::= begin [ : block_identifier
                { block_item_declaration } ] { function_statement } end
variable_assignment ::= variable_lvalue = expression
par_block ::= fork [ : block_identifier ]
                { block_item_declaration } ]
                { statement } join [ : block_identifier ]
seq_block ::= begin [ : block_identifier ]
                { block_item_declaration } ]
                { statement } end [ : block_identifier ]

A.6.4 Statements

A.6.5 Timing control statements

delay_control ::=
          # delay_value
        | # ( mintypmax_expression )
delay_or_event_control ::=
          delay_control
        | event_control
        | repeat ( expression ) event_control
disable_statement ::=
          disable hierarchical_task_identifier ;
        | disable hierarchical_block_identifier ;
event_control ::=
          @ event_identifier
        | @ ( event_expression )
        | @*
        | @ (*)
event_trigger ::=
          -> hierarchical_event_identifier ;
event_expression ::=
          expression [ iff expression ]
        | hierarchical_identifier [ iff expression ]
        | [ edge ] expression [ iff expression ]
        | negedge expression
        | event_expression or event_expression
        | event_expression , event_expression
edge ::= posedge | negedge | changed
jump_statement ::=
          return [ expression ] ;
        | break ;
        | continue ;
procedural_timing_control_statement ::=
          delay_or_event_control statement_or_null
wait_statement ::=
          wait ( expression ) statement_or_null

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 Transition statements

transition_statement ::=
          transition ( hierarchical_identifier )
          transition_item { transition_item } endtransition
function_transition_statement ::=
          transition ( hierarchical_identifier )
          function_transition_item { function_transition_item } endtransition
transition_item ::=
          list_of_state_conditions : statement_or_null
        | default [ : ] statement_or_null
function_transition_item ::=
          list_of_state_conditions : function_statement_or_null
        | default [ : ] function_statement_or_null
list_of_state_conditions ::= state_condition { , state_condition }
state_condition ::= state_identifier { and state_identifier }
transition_to_state ::=
          ->> hierarchical_identifier . state_identifier
        | ->> hierarchical_identifier . ( state_condition )
        | [ transition_identifier ] ->> state_condition

A.6.9 Looping statements

function_loop_statement ::=
          forever function_statement
        | 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 while ( expression )
loop_statement ::=
          forever statement
        | repeat ( expression ) statement_or_null
        | while ( expression ) statement_or_null
        | for ( variable_decl_or_assignment ;  expression ; variable_assignment )
                  statement_or_null
        | do statement while ( expression )
variable_decl_or_assignment ::=
          data_type list_of_variable_identifiers_or_assignments ;
        | variable_assignment

A.6.10 Task enable statements

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

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
        | input_identifier [ constant_expression ]
        | input_identifier [ range_expression ]
specify_output_terminal_descriptor ::=
          output_identifier
        | output_identifier [ constant_expression ]
        | output_identifier [ range_expression ]
input_identifier ::= input_port_identifier | inout_port_identifier
output_identifier ::= output_port_identifier | inout_port_identifier

A.7.4 Specify path delays

A.7.5 System timing checks

A.7.5.1 System timing check commands

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 [ , [ notify_reg ] ] ) ;
$hold _timing_check ::=
          $hold ( reference_event , data_event , timing_check_limit [ , [ notify_reg ] ] ) ;
$setuphold_timing_check ::=
          $setuphold ( reference_event , data_event , timing_check_limit ,  timing_check_limit
                                        [ , [ notify_reg ] [ , [ stamptime_condition ] [ , [ checktime_condition ]
                                        [ , [ delayed_reference ] [ , [ delayed_data ] ] ] ] ] ] ) ;
$recovery_timing_check ::=
          $recovery ( reference_event , data_event , timing_check_limit [ , [ notify_reg ] ] ) ;
$removal_timing_check ::=
          $removal ( reference_event , data_event , timing_check_limit [ , [ notify_reg ] ] ) ;
$recrem_timing_check ::=
          $recrem ( reference_event , data_event , timing_check_limit , timing_check_limit
                                        [ , [ notify_reg ] [ , [ stamptime_condition ] [ , [ checktime_condition ]
                                        [ , [ delayed_reference ] [ , [ delayed_data ] ] ] ] ] ] ) ;
$skew_timing_check ::=
          $skew ( reference_event , data_event , timing_check_limit [ , [ notify_reg ] ] ) ;
$timeskew_timing_check ::=
          $timeskew ( reference_event , data_event , timing_check_limit
                                        [ , [ notify_reg ] [ , [ event_based_flag ] [ , [ remain_active_flag ] ] ] ] ) ;
$fullskew_timing_check ::=
          $fullskew ( reference_event , data_event , timing_check_limit , timing_check_limit
                                        [ , [ notify_reg ] [ , [ event_based_flag ] [ , [ remain_active_flag ] ] ] ] ) ;
$period_timing_check ::=
          $period ( controlled_reference_event , timing_check_limit [ , [ notify_reg ] ] ) ;
$width_timing_check ::=
          $width ( controlled_reference_event , timing_check_limit ,
                                        threshold [ , [ notify_reg ] ] ) ;
$nochange_timing_check ::=
          $nochange ( reference_event , data_event , start_edge_offset ,
                                        end_edge_offset [ , [ notify_reg ] ] ) ;

A.7.5.2 System timing check command arguments

checktime_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
notify_reg ::= variable_identifier
reference_event ::= timing_check_event
remain_active_flag ::= constant_mintypmax_expression
stamptime_condition ::= mintypmax_expression
start_edge_offset ::= mintypmax_expression
threshold ::=constant_expression
timing_check_limit ::= expression

A.7.5.3 System timing check event definitions

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

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 }
net_concatenation ::= { net_concatenation_value { , net_concatenation_value } }
net_concatenation_value ::=
          hierarchical_net_identifier
        | hierarchical_net_identifier [ expression ] { [ expression ] }
        | hierarchical_net_identifier [ expression ] { [ expression ] } [ range_expression ]
        | hierarchical_net_identifier [ range_expression ]
        | net_concatenation
variable_concatenation ::= { variable_concatenation_value { , variable_concatenation_value } }
variable_concatenation_value ::=
          hierarchical_variable_identifier
        | hierarchical_variable_identifier [ expression ] { [ expression ] }
        | hierarchical_variable_identifier [ expression ] { [ expression ] } [ range_expression ]
        | hierarchical_variable_identifier [ range_expression ]
        | variable_concatenation

A.8.2 Function calls

constant_function_call ::= function_identifier { attribute_instance }
                  ( constant_expression { , constant_expression } )
function_call ::= hierarchical_function_identifier{ attribute_instance }
                  ( expression { , expression } )
genvar_function_call ::= genvar_function_identifier { attribute_instance }
                  ( constant_expression { , constant_expression } )
system_function_call ::= system_function_identifier
                  [ ( expression { , expression } ) ]

A.8.3 Expressions

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
        | hierarchical_identifier [ expression ] { [ expression ] }
        | hierarchical_identifier [ expression ] { [ expression ] }  [ range_expression ]
        | hierarchical_identifier [ range_expression ]
        | concatenation
        | multiple_concatenation
        | function_call
        | system_function_call
        | constant_function_call
        | ( mintypmax_expression )
        | ( expression )
        | { expression { , expression } }
        | { expression { expression } }
        | simple_type ' ( expression )
        | simple_type ' { expression { , expression } }
        | simple_type ' { expression { expression } }
        | time_literal
        | '0 | '1 | 'z | 'Z | 'x | 'X
time_literal ::= integer [ . integer ] time_unit
time_unit ::= s | ms | us | ns | ps | fs

A.8.5 Expression left-side values

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
real_number₁ ::=
          unsigned_number . unsigned_number
        | unsigned_number [ . unsigned_number ] exp [ sign ] unsigned_number
exp ::= e | E
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}
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 | ?

A.8.8 Strings

string ::= " { Any_ASCII_Characters_except_new_line } "

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

A.9.4 Identifier branches

simple_hierarchical_branch₃ ::=
          simple_identifier [{ [ unsigned_number ] ]}
                [ { . simple_identifier [{ [ unsigned_number ] ]} } ]
escaped_hierarchical_branch₄ ::=
          escaped_identifier [{ [ unsigned_number ] ]}
                [ { . escaped_identifier [{ [ unsigned_number ] ]} } ]

A.9.5 White space

white_space ::= space | tab | newline | eof₆
NOTES
1)      Embedded spaces are illegal.
2)      A simple_identifier and arrayed_reference shall start with an alpha or underscore (_) character, shall have at least one character, and shall not have any spaces.
3)      The period (.) in simple_hierarchical_identifier and simple_hierarchical_
branch shall not be preceded or followed by white_space.
4)      The period in escaped_hierarchical_identifier and escaped_hierarchical_
branch shall be preceded by white_space, but shall not be followed by white_space.
5)      The $ character in a system_function_identifier or system_task_identifier shall not be followed by white_space. A system_function_identifier or system_task_identifier shall not be escaped.
6)      End of file.