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

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

interface_item ::=
          port_declaration
        | non_port_interface_item

non_port_interface_item ::=
          { attribute_instance } generated_interface_instantiation
        | { attribute_instance } local_parameter_declaration
        | { attribute_instance } parameter_declaration
        | { attribute_instance } specparam_declaration
        | interface_or_generate_item
        | interface_declaration

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 data_type list_of_param_assignments ;

parameter_declaration ::=
          parameter [ signing ] { packed_dimension } [ range ] 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 [ port_type ] list_of_port_identifiers
        | inout . port_identifier ( [ port_expression ] )

input_declaration ::= input [ port_type ] list_of_port_identifiers
        | input . port_identifier ( [ port_expression ] )

output_declaration ::=
          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 ;

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 ;

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

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

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
        | [ 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_statement }
            endfunction [ : function_identifier ]
           | function [ automatic ] [ signing ] [ range_or_type ]
                  [ interface_identifier . ] function_identifier ( function_port_list ) ;
            { 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_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_data_declaration
        | { attribute_instance } event_declaration
        | { attribute_instance } local_parameter_declaration
        | { attribute_instance } parameter_declaration

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
        | import_export task_or_function_identifier { , task_or_function_identifier }

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

module_instantiation ::=
          module_identifier [ parameter_value_assignment ]
              module_instance { , module_instance } ;

parameter_value_assignment ::= # ( list_of_parameter_assignments )

list_of_parameter_assignments ::=
        ordered_parameter_assignment { , ordered_parameter_assignment } |
        named_parameter_assignment   { , named_parameter_assignment }

ordered_parameter_assignment ::= expression | data_type

named_parameter_assignment ::=
          . parameter_identifier ( [ expression ] )
        | . parameter_identifier ( [ data_type ] )

module_instance ::= name_of_instance ( [ list_of_port_connections ] )

name_of_instance ::= module_instance_identifier { range }

list_of_port_connections ::=
          ordered_port_connection { , ordered_port_connection }
        | named_port_connection { , named_port_connection }
list_of_port_connections ::=
          ordered_port_connection { , ordered_port_connection }
        | dot_named_port_connection { , dot_named_port_connection }
        | { named_port_connection , } dot_star_port_connection
          { , named_port_connection }

ordered_port_connection ::= { attribute_instance } [ expression ]

named_port_connection ::= { attribute_instance } .port_identifier ( [ expression ] )

dot_named_port_connection ::=
          { attribute_instance } .port_identifier
        | named_port_connection

dot_star_port_connection ::= { attribute_instance } .*

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

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 ]
        | 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.8 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.9 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

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.