Re: Hyperlinked BNF verilog 2001

From: Shalom Bresticker (Shalom.Bresticker@motorola.com)
Date: Sun Sep 09 2001 - 07:34:15 PDT

Next message: Tom Fitzpatrick: "errata/35: Errata/clarification: Use of work "type" in section 4.5"
Previous message: Paul Graham: "implicit wires"
Maybe in reply to: Adam Krolnik: "Hyperlinked BNF verilog 2001"
Next in thread: Dennis Marsa: "Re: variable initialization at declaration"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ] [ attachment ]

OK, it took a lot more time than I was planning on, but I finally finished my
revision of Adam's hyperlinked HTML version of the 1364-2001 BNF.

In addition to fixing some formatting and errors that crept into the translation
from the book to the HTML version, I corrected some minor errors that were
noticed recently (all of them are recorded in Stefen's BTF bug database) and
updated the task/function port declaration syntax from the erroneous Draft 6
version to the corrected printed version.

If there are any problems or suggestions for improvements,
tell me and I'll look at them.

A side-benefit of this work is that I am fast becoming an HTML expert.

Shalom

<TITLE>IEEE 1364-2001 Annex A Formal Syntax Definition</TITLE>
<BODY BGCOLOR="#FFFFFF">
<TT>

<H1>Annex A</H1>
<H2>A.1 Source text</H2>
<H3>A.1.1 Library source text</H3>
<A NAME="library_text">library_text</A> ::= { <A NAME="Rlibrary_descriptions" HREF="#library_descriptions">library_descriptions</A> }

<A NAME="library_descriptions" HREF="#Rlibrary_descriptions">library_descriptions</A> ::=
 <A NAME="Rlibrary_declaration" HREF="#library_declaration">library_declaration</A>
 | <A NAME="Rinclude_statement" HREF="#include_statement">include_statement</A>
 | <A NAME="Rconfig_declaration" HREF="#config_declaration">config_declaration</A>

<A NAME="library_declaration" HREF="#Rlibrary_declaration">library_declaration</A> ::=
library <A NAME="Rlibrary_identifier" HREF="#library_identifier">library_identifier</A> <A NAME="Rfile_path_spec" HREF="#file_path_spec">file_path_spec</A> [ { , file_path_spec } ]
[ -incdir file_path_spec [ { , file_path_spec } ] ;

<A NAME="file_path_spec" HREF="#Rfile_path_spec">file_path_spec</A> ::= file_path

<A NAME="include_statement" HREF="#Rinclude_statement">include_statement</A> ::= include <file_path_spec> ;

<H3>A.1.2 Configuration source text</H3>
<A NAME="config_declaration" HREF="#Rconfig_declaration">config_declaration</A> ::=
 config <A NAME="Rconfig_identifier" HREF="#config_identifier">config_identifier</A> ;
 <A NAME="Rdesign_statement" HREF="#design_statement">design_statement</A>
 {<A NAME="Rconfig_rule_statement" HREF="#config_rule_statement">config_rule_statement</A>}
 endconfig

<A NAME="design_statement" HREF="#Rdesign_statement">design_statement</A> ::= design { [library_identifier.]<A NAME="Rcell_identifier" HREF="#cell_identifier">cell_identifier</A> } ;

<A NAME="config_rule_statement" HREF="#Rconfig_rule_statement">config_rule_statement</A> ::=
 <A NAME="Rdefault_clause" HREF="#default_clause">default_clause</A> <A NAME="Rliblist_clause" HREF="#liblist_clause">liblist_clause</A>
 | <A NAME="Rinst_clause" HREF="#inst_clause">inst_clause</A> liblist_clause
 | inst_clause <A NAME="Ruse_clause" HREF="#use_clause">use_clause</A>
 | <A NAME="Rcell_clause" HREF="#cell_clause">cell_clause</A> liblist_clause
 | cell_clause use_clause

<A NAME="default_clause" HREF="#Rdefault_clause">default_clause</A> ::= default

<A NAME="inst_clause" HREF="#Rinst_clause">inst_clause</A> ::= instance <A NAME="Rinst_name" HREF="#inst_name">inst_name</A>

<A NAME="inst_name" HREF="#Rinst_name">inst_name</A> ::= <A NAME="Rtopmodule_identifier" HREF="#topmodule_identifier">topmodule_identifier</A>{.<A NAME="Rinstance_identifier" HREF="#instance_identifier">instance_identifier</A>}

<A NAME="cell_clause" HREF="#Rcell_clause">cell_clause</A> ::= cell [ library_identifier.]cell_identifier

<A NAME="liblist_clause" HREF="#Rliblist_clause">liblist_clause</A> ::= liblist [{library_identifier}]

<A NAME="use_clause" HREF="#Ruse_clause">use_clause</A> ::= use [library_identifier.]cell_identifier[:config]

<H3>A.1.3 Module and primitive source text</H3>
<A NAME="source_text">source_text</A> ::= { <A NAME="Rdescription" HREF="#description">description</A> }

<A NAME="description" HREF="#Rdescription">description</A> ::=
<A NAME="Rmodule_declaration" HREF="#module_declaration">module_declaration</A>
| <A NAME="Rudp_declaration" HREF="#udp_declaration">udp_declaration</A>

<A NAME="module_declaration" HREF="#Rmodule_declaration">module_declaration</A> ::=
 { <A NAME="Rattribute_instance" HREF="#attribute_instance">attribute_instance</A> } <A NAME="Rmodule_keyword" HREF="#module_keyword">module_keyword</A> <A NAME="Rmodule_identifier" HREF="#module_identifier">module_identifier</A>
 [ <A NAME="Rmodule_parameter_port_list" HREF="#module_parameter_port_list">module_parameter_port_list</A> ] [ <A NAME="Rlist_of_ports" HREF="#list_of_ports">list_of_ports</A> ] ;
 { <A NAME="Rmodule_item" HREF="#module_item">module_item</A> }
 endmodule
 | { attribute_instance } module_keyword module_identifier
 [ module_parameter_port_list ] [ <A NAME="Rlist_of_port_declarations" HREF="#list_of_port_declarations">list_of_port_declarations</A> ] ;
 { <A NAME="Rnon_port_module_item" HREF="#non_port_module_item">non_port_module_item</A> }
 endmodule

<A NAME="module_keyword" HREF="#Rmodule_keyword">module_keyword</A> ::= module | macromodule

<H3>A.1.4 Module parameters and ports</H3>
<A NAME="module_parameter_port_list" HREF="#Rmodule_parameter_port_list">module_parameter_port_list</A> ::= # ( <A NAME="Rparameter_declaration" HREF="#parameter_declaration">parameter_declaration</A> {, parameter_declaration} )

<A NAME="list_of_ports" HREF="#Rlist_of_ports">list_of_ports</A> ::= ( <A NAME="Rport" HREF="#port">port</A> { , port } )

<A NAME="list_of_port_declarations" HREF="#Rlist_of_port_declarations">list_of_port_declarations</A> ::=
( <A NAME="Rport_declaration" HREF="#port_declaration">port_declaration</A> { , port_declaration } )
| ( )

<A NAME="port" HREF="#Rport">port</A> ::=
[ <A NAME="Rport_expression" HREF="#port_expression">port_expression</A> ]
| . <A NAME="Rport_identifier" HREF="#port_identifier">port_identifier</A> ( [ port_expression ] )

<A NAME="port_expression" HREF="#Rport_expression">port_expression</A> ::=
<A NAME="Rport_reference" HREF="#port_reference">port_reference</A>
| { port_reference { , port_reference } }

<A NAME="port_reference" HREF="#Rport_reference">port_reference</A> ::=
 port_identifier
 | port_identifier [ <A NAME="Rconstant_expression" HREF="#constant_expression">constant_expression</A> ]
 | port_identifier [ <A NAME="Rrange_expression" HREF="#range_expression">range_expression</A> ]

<A NAME="port_declaration" HREF="#Rport_declaration">port_declaration</A> ::=
 {attribute_instance} <A NAME="Rinout_declaration" HREF="#inout_declaration">inout_declaration</A>
 | {attribute_instance} <A NAME="Rinput_declaration" HREF="#input_declaration">input_declaration</A>
 | {attribute_instance} <A NAME="Routput_declaration" HREF="#output_declaration">output_declaration</A>

<H3>A.1.5 Module items</H3>
<A NAME="module_item" HREF="#Rmodule_item">module_item</A> ::=
 <A NAME="Rmodule_or_generate_item" HREF="#module_or_generate_item">module_or_generate_item</A>
 | port_declaration ;
 | { attribute_instance } <A NAME="Rgenerated_instantiation" HREF="#generated_instantiation">generated_instantiation</A>
 | { attribute_instance } <A NAME="Rlocal_parameter_declaration" HREF="#local_parameter_declaration">local_parameter_declaration</A>
 | { attribute_instance } parameter_declaration
 | { attribute_instance } <A NAME="Rspecify_block" HREF="#specify_block">specify_block</A>
 | { attribute_instance } <A NAME="Rspecparam_declaration" HREF="#specparam_declaration">specparam_declaration</A>

<A NAME="module_or_generate_item" HREF="#Rmodule_or_generate_item">module_or_generate_item</A> ::=
 { attribute_instance } <A NAME="Rmodule_or_generate_item_declaration" HREF="#module_or_generate_item_declaration">module_or_generate_item_declaration</A>
 | { attribute_instance } <A NAME="Rparameter_override" HREF="#parameter_override">parameter_override</A>
 | { attribute_instance } <A NAME="Rcontinuous_assign" HREF="#continuous_assign">continuous_assign</A>
 | { attribute_instance } <A NAME="Rgate_instantiation" HREF="#gate_instantiation">gate_instantiation</A>
 | { attribute_instance } <A NAME="Rudp_instantiation" HREF="#udp_instantiation">udp_instantiation</A>
 | { attribute_instance } <A NAME="Rmodule_instantiation" HREF="#module_instantiation">module_instantiation</A>
 | { attribute_instance } <A NAME="Rinitial_construct" HREF="#initial_construct">initial_construct</A>
 | { attribute_instance } <A NAME="Ralways_construct" HREF="#always_construct">always_construct</A>

<A NAME="module_or_generate_item_declaration" HREF="#Rmodule_or_generate_item_declaration">module_or_generate_item_declaration</A> ::=
 <A NAME="Rnet_declaration" HREF="#net_declaration">net_declaration</A>
 | <A NAME="Rreg_declaration" HREF="#reg_declaration">reg_declaration</A>
 | <A NAME="Rinteger_declaration" HREF="#integer_declaration">integer_declaration</A>
 | <A NAME="Rreal_declaration" HREF="#real_declaration">real_declaration</A>
 | <A NAME="Rtime_declaration" HREF="#time_declaration">time_declaration</A>
 | <A NAME="Rrealtime_declaration" HREF="#realtime_declaration">realtime_declaration</A>
 | <A NAME="Revent_declaration" HREF="#event_declaration">event_declaration</A>
 | <A NAME="Rgenvar_declaration" HREF="#genvar_declaration">genvar_declaration</A>
 | <A NAME="Rtask_declaration" HREF="#task_declaration">task_declaration</A>
 | <A NAME="Rfunction_declaration" HREF="#function_declaration">function_declaration</A>

<A NAME="non_port_module_item" HREF="#Rnon_port_module_item">non_port_module_item</A> ::=
 { attribute_instance } generated_instantiation
 | { attribute_instance } local_parameter_declaration
 | { attribute_instance } module_or_generate_item
 | { attribute_instance } parameter_declaration
 | { attribute_instance } specify_block
 | { attribute_instance } specparam_declaration

<A NAME="parameter_override" HREF="#Rparameter_override">parameter_override</A> ::= defparam <A NAME="Rlist_of_param_assignments" HREF="#list_of_param_assignments">list_of_param_assignments</A> ;

<H2>A.2 Declarations</H2>
<H3>A.2.1 Declaration types</H3>
<H4>A.2.1.1 Module parameter declarations</H4>
<A NAME="local_parameter_declaration" HREF="#Rlocal_parameter_declaration">local_parameter_declaration</A> ::=
 localparam [ signed ] [ <A NAME="Rrange" HREF="#range">range</A> ] 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 ;

<A NAME="parameter_declaration" HREF="#Rparameter_declaration">parameter_declaration</A> ::=
 parameter [ signed ] [ 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 ;

<A NAME="specparam_declaration" HREF="#Rspecparam_declaration">specparam_declaration</A> ::= specparam [ range ] <A NAME="Rlist_of_specparam_assignments" HREF="#list_of_specparam_assignments">list_of_specparam_assignments</A> ;

<H4>A.2.1.2 Port declarations</H4>
<A NAME="inout_declaration" HREF="#Rinout_declaration">inout_declaration</A> ::= inout [ <A NAME="Rnet_type" HREF="#net_type">net_type</A> ] [ signed ] [ range ]
<A NAME="Rlist_of_port_identifiers" HREF="#list_of_port_identifiers">list_of_port_identifiers</A>

<A NAME="input_declaration" HREF="#Rinput_declaration">input_declaration</A> ::= input [ net_type ] [ signed ] [ range ]
list_of_port_identifiers

<A NAME="output_declaration" HREF="#Routput_declaration">output_declaration</A> ::=
 output [ net_type ] [ signed ] [ range ] list_of_port_identifiers
 | output [ reg ] [ signed ] [ range ] list_of_port_identifiers
 | output reg [ signed ] [ range ] <A NAME="Rlist_of_variable_port_identifiers" HREF="#list_of_variable_port_identifiers">list_of_variable_port_identifiers</A>
 | output [ <A NAME="Routput_variable_type" HREF="#output_variable_type">output_variable_type</A> ] list_of_port_identifiers
 | output output_variable_type list_of_variable_port_identifiers

<H4>A.2.1.3 Type declarations</H4>
<A NAME="event_declaration" HREF="#Revent_declaration">event_declaration</A> ::= event <A NAME="Rlist_of_event_identifiers" HREF="#list_of_event_identifiers">list_of_event_identifiers</A> ;

<A NAME="genvar_declaration" HREF="#Rgenvar_declaration">genvar_declaration</A> ::= genvar <A NAME="Rlist_of_genvar_identifiers" HREF="#list_of_genvar_identifiers">list_of_genvar_identifiers</A> ;

<A NAME="integer_declaration" HREF="#Rinteger_declaration">integer_declaration</A> ::= integer <A NAME="Rlist_of_variable_identifiers" HREF="#list_of_variable_identifiers">list_of_variable_identifiers</A> ;

<A NAME="net_declaration" HREF="#Rnet_declaration">net_declaration</A> ::=
 net_type [ signed ] [ <A NAME="Rdelay3" HREF="#delay3">delay3</A> ] <A NAME="Rlist_of_net_identifiers" HREF="#list_of_net_identifiers">list_of_net_identifiers</A> ;
 | net_type [ <A NAME="Rdrive_strength" HREF="#drive_strength">drive_strength</A> ] [ signed ] [ delay3 ] <A NAME="Rlist_of_net_decl_assignments" HREF="#list_of_net_decl_assignments">list_of_net_decl_assignments</A> ;
 | net_type [ vectored | scalared ] [ signed ] range [ delay3 ]
 list_of_net_identifiers ;
 | net_type [ drive_strength ] [ vectored | scalared ][ signed ] range [ delay3 ]
 list_of_net_decl_assignments ;
 | trireg [ <A NAME="Rcharge_strength" HREF="#charge_strength">charge_strength</A> ] [ signed ] [ delay3 ] list_of_net_identifiers ;
 | trireg [ drive_strength ] [ signed ] [ delay3 ] list_of_net_decl_assignments ;
 | trireg [ charge_strength ] [ vectored | scalared ] [ signed ] range [ delay3 ]
 list_of_net_identifiers ;
 | trireg [ drive_strength ] [ vectored | scalared ] [ signed ] range [ delay3 ]
 list_of_net_decl_assignments ;

<A NAME="real_declaration" HREF="#Rreal_declaration">real_declaration</A> ::= real <A NAME="Rlist_of_real_identifiers" HREF="#list_of_real_identifiers">list_of_real_identifiers</A> ;

<A NAME="realtime_declaration" HREF="#Rrealtime_declaration">realtime_declaration</A> ::= realtime list_of_real_identifiers ;

<A NAME="reg_declaration" HREF="#Rreg_declaration">reg_declaration</A> ::= reg [ signed ] [ range ] list_of_variable_identifiers ;

<A NAME="time_declaration" HREF="#Rtime_declaration">time_declaration</A> ::= time list_of_variable_identifiers ;

<A NAME="output_variable_type" HREF="#Routput_variable_type">output_variable_type</A> ::= integer | time

<A NAME="real_type" HREF="#Rreal_type">real_type</A> ::=
<A NAME="Rreal_identifier" HREF="#real_identifier">real_identifier</A> [ = constant_expression ]
| real_identifier <A NAME="Rdimension" HREF="#dimension">dimension</A> { dimension }

<A NAME="variable_type" HREF="#Rvariable_type">variable_type</A> ::=
<A NAME="Rvariable_identifier" HREF="#variable_identifier">variable_identifier</A> [ = constant_expression ]
| variable_identifier dimension { dimension }

<H4>A.2.2.2 Strengths</H4>
<A NAME="drive_strength" HREF="#Rdrive_strength">drive_strength</A> ::=
 ( <A NAME="Rstrength0" HREF="#strength0">strength0</A> , <A NAME="Rstrength1" HREF="#strength1">strength1</A> )
 | ( strength1 , strength0 )
 | ( strength0 , highz1 )
 | ( strength1 , highz0 )
 | ( highz0 , strength1 )
 | ( highz1 , strength0 )

<A NAME="strength0" HREF="#Rstrength0">strength0</A> ::= supply0 | strong0 | pull0 | weak0

<A NAME="strength1" HREF="#Rstrength1">strength1</A> ::= supply1 | strong1 | pull1 | weak1

<A NAME="charge_strength" HREF="#Rcharge_strength">charge_strength</A> ::= ( small ) | ( medium ) | ( large )

<H4>A.2.2.3 Delays</H4>
<A NAME="delay3" HREF="#Rdelay3">delay3</A> ::= # <A NAME="Rdelay_value" HREF="#delay_value">delay_value</A> | # ( delay_value [ , delay_value [ , delay_value ] ] )

<A NAME="delay2" HREF="#Rdelay2">delay2</A> ::= # delay_value | # ( delay_value [ , delay_value ] )

<A NAME="delay_value" HREF="#Rdelay_value">delay_value</A> ::=
 <A NAME="Runsigned_number" HREF="#unsigned_number">unsigned_number</A>
 | <A NAME="Rparameter_identifier" HREF="#parameter_identifier">parameter_identifier</A>
 | <A NAME="Rspecparam_identifier" HREF="#specparam_identifier">specparam_identifier</A>
 | <A NAME="Rmintypmax_expression" HREF="#mintypmax_expression">mintypmax_expression</A>

<H3>A.2.3 Declaration lists</H3>
<A NAME="list_of_event_identifiers" HREF="#Rlist_of_event_identifiers">list_of_event_identifiers</A> ::= <A NAME="Revent_identifier" HREF="#event_identifier">event_identifier</A> [ dimension { dimension } ]
{ , event_identifier [ dimension { dimension } ] }

<A NAME="list_of_genvar_identifiers" HREF="#Rlist_of_genvar_identifiers">list_of_genvar_identifiers</A> ::= <A NAME="Rgenvar_identifier" HREF="#genvar_identifier">genvar_identifier</A> { , genvar_identifier }

<A NAME="list_of_net_decl_assignments" HREF="#Rlist_of_net_decl_assignments">list_of_net_decl_assignments</A> ::= <A NAME="Rnet_decl_assignment" HREF="#net_decl_assignment">net_decl_assignment</A> { , net_decl_assignment }

<A NAME="list_of_net_identifiers" HREF="#Rlist_of_net_identifiers">list_of_net_identifiers</A> ::= <A NAME="Rnet_identifier" HREF="#net_identifier">net_identifier</A> [ dimension { dimension } ]
{ , net_identifier [ dimension { dimension } ] }

<A NAME="list_of_param_assignments" HREF="#Rlist_of_param_assignments">list_of_param_assignments</A> ::= <A NAME="Rparam_assignment" HREF="#param_assignment">param_assignment</A> { , param_assignment }

<A NAME="list_of_port_identifiers" HREF="#Rlist_of_port_identifiers">list_of_port_identifiers</A> ::= port_identifier { , port_identifier }

<A NAME="list_of_real_identifiers" HREF="#Rlist_of_real_identifiers">list_of_real_identifiers</A> ::= real_type { , real_type }

<A NAME="list_of_specparam_assignments" HREF="#Rlist_of_specparam_assignments">list_of_specparam_assignments</A> ::= <A NAME="Rspecparam_assignment" HREF="#specparam_assignment">specparam_assignment</A> { , specparam_assignment }

<A NAME="list_of_variable_identifiers" HREF="#Rlist_of_variable_identifiers">list_of_variable_identifiers</A> ::= variable_type { , variable_type }

<A NAME="list_of_variable_port_identifiers" HREF="#Rlist_of_variable_port_identifiers">list_of_variable_port_identifiers</A> ::= port_identifier [ = constant_expression ]
{ , port_identifier [ = constant_expression ] }

<H3>A.2.4 Declaration assignments</H3>
<A NAME="net_decl_assignment" HREF="#Rnet_decl_assignment">net_decl_assignment</A> ::= net_identifier = <A NAME="Rexpression" HREF="#expression">expression</A>

<A NAME="param_assignment" HREF="#Rparam_assignment">param_assignment</A> ::= parameter_identifier = constant_expression

<A NAME="specparam_assignment" HREF="#Rspecparam_assignment">specparam_assignment</A> ::=
specparam_identifier = <A NAME="Rconstant_mintypmax_expression" HREF="#constant_mintypmax_expression">constant_mintypmax_expression</A>
| <A NAME="Rpulse_control_specparam" HREF="#pulse_control_specparam">pulse_control_specparam</A>

<A NAME="pulse_control_specparam" HREF="#Rpulse_control_specparam">pulse_control_specparam</A> ::=
 PATHPULSE$ = ( <A NAME="Rreject_limit_value" HREF="#reject_limit_value">reject_limit_value</A> [ , <A NAME="Rerror_limit_value" HREF="#error_limit_value">error_limit_value</A> ] ) ;
 | PATHPULSE$<A NAME="Rspecify_input_terminal_descriptor" HREF="#specify_input_terminal_descriptor">specify_input_terminal_descriptor</A>$<A NAME="Rspecify_output_terminal_descriptor" HREF="#specify_output_terminal_descriptor">specify_output_terminal_descriptor</A>
 = ( reject_limit_value [ , error_limit_value ] ) ;

<A NAME="error_limit_value" HREF="#Rerror_limit_value">error_limit_value</A> ::= <A NAME="Rlimit_value" HREF="#limit_value">limit_value</A>

<A NAME="reject_limit_value" HREF="#Rreject_limit_value">reject_limit_value</A> ::= limit_value

<A NAME="limit_value" HREF="#Rlimit_value">limit_value</A> ::= constant_mintypmax_expression

<H3>A.2.5 Declaration ranges</H3>
<A NAME="dimension" HREF="#Rdimension">dimension</A> ::= [ <A NAME="Rdimension_constant_expression" HREF="#dimension_constant_expression">dimension_constant_expression</A> : dimension_constant_expression ]

<A NAME="range" HREF="#Rrange">range</A> ::= [ <A NAME="Rmsb_constant_expression" HREF="#msb_constant_expression">msb_constant_expression</A> : <A NAME="Rlsb_constant_expression" HREF="#lsb_constant_expression">lsb_constant_expression</A> ]

<H3>A.2.6 Function declarations</H3>
<A NAME="function_declaration" HREF="#Rfunction_declaration">function_declaration</A> ::=
 function [ automatic ] [ signed ] [ <A NAME="Rrange_or_type" HREF="#range_or_type">range_or_type</A> ] <A NAME="Rfunction_identifier" HREF="#function_identifier">function_identifier</A> ;
 <A NAME="Rfunction_item_declaration" HREF="#function_item_declaration">function_item_declaration</A> { function_item_declaration }
 <A NAME="Rfunction_statement" HREF="#function_statement">function_statement</A>
 endfunction
 | function [ automatic ] [ signed ] [ range_or_type ]
 function_identifier ( <A NAME="Rfunction_port_list" HREF="#function_port_list">function_port_list</A> ) ;
 <A NAME="Rblock_item_declaration" HREF="#block_item_declaration">block_item_declaration</A> { block_item_declaration }
 function_statement
 endfunction

<A NAME="function_item_declaration" HREF="#Rfunction_item_declaration">function_item_declaration</A> ::=
block_item_declaration
| <A NAME="Rtf_input_declaration" HREF="#tf_input_declaration">tf_input_declaration</A> ;

<A NAME="function_port_list" HREF="#Rfunction_port_list">function_port_list</A> ::= { attribute_instance } tf_input_declaration
{ , { attribute_instance } tf_input_declaration }

<A NAME="range_or_type" HREF="#Rrange_or_type">range_or_type</A> ::= range | integer | real | realtime | time

<H3>A.2.7 Task declarations</H3>
<A NAME="task_declaration" HREF="#Rtask_declaration">task_declaration</A> ::=
 task [ automatic ] <A NAME="Rtask_identifier" HREF="#task_identifier">task_identifier</A> ;
 { <A NAME="Rtask_item_declaration" HREF="#task_item_declaration">task_item_declaration</A> }
 <A NAME="Rstatement" HREF="#statement">statement</A>
 endtask
 | task [ automatic ] task_identifier ( <A NAME="Rtask_port_list" HREF="#task_port_list">task_port_list</A> ) ;
 { block_item_declaration }
 statement
 endtask

<A NAME="task_item_declaration" HREF="#Rtask_item_declaration">task_item_declaration</A> ::=
 block_item_declaration
 | { attribute_instance } tf_input_declaration ;
 | { attribute_instance } <A NAME="Rtf_output_declaration" HREF="#tf_output_declaration">tf_output_declaration</A> ;
 | { attribute_instance } <A NAME="Rtf_inout_declaration" HREF="#tf_inout_declaration">tf_inout_declaration</A> ;

<A NAME="task_port_list" HREF="#Rtask_port_list">task_port_list</A> ::= <A NAME="Rtask_port_item" HREF="#task_port_item">task_port_item</A> { , task_port_item }

<A NAME="task_port_item" HREF="#Rtask_port_item">task_port_item</A> ::=
 { attribute_instance } tf_input_declaration
 | { attribute_instance } tf_output_declaration
 | { attribute_instance } tf_inout_declaration

<A NAME="tf_input_declaration" HREF="#Rtf_input_declaration">tf_input_declaration</A> ::=
input [ reg ] [ signed ] [ range ] list_of_port_identifiers
| input [ <A NAME="Rtask_port_type" HREF="#task_port_type">task_port_type</A> ] list_of_port_identifiers

<A NAME="tf_output_declaration" HREF="#Rtf_output_declaration">tf_output_declaration</A> ::=
output [ reg ] [ signed ] [ range ] list_of_port_identifiers
| output [ task_port_type ] list_of_port_identifiers

<A NAME="tf_inout_declaration" HREF="#Rtf_inout_declaration">tf_inout_declaration</A> ::=
inout [ reg ] [ signed ] [ range ] list_of_port_identifiers
| inout [ task_port_type ] list_of_port_identifiers

<A NAME="task_port_type" HREF="#Rtask_port_type">task_port_type</A> ::= time | real | realtime | integer

<H3>A.2.8 Block item declarations</H3>
<A NAME="block_item_declaration" HREF="#Rblock_item_declaration">block_item_declaration</A> ::=
 { attribute_instance } <A NAME="Rblock_reg_declaration" HREF="#block_reg_declaration">block_reg_declaration</A>
 | { 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

<A NAME="block_reg_declaration" HREF="#Rblock_reg_declaration">block_reg_declaration</A> ::=
reg [ signed ] [ range ] <A NAME="Rlist_of_block_variable_identifiers" HREF="#list_of_block_variable_identifiers">list_of_block_variable_identifiers</A> ;

<A NAME="list_of_block_variable_identifiers" HREF="#Rlist_of_block_variable_identifiers">list_of_block_variable_identifiers</A> ::=
<A NAME="Rblock_variable_type" HREF="#block_variable_type">block_variable_type</A> { , block_variable_type }

<A NAME="block_variable_type" HREF="#Rblock_variable_type">block_variable_type</A> ::=
variable_identifier
| variable_identifier dimension { dimension }

<H2>A.3 Primitive instances</H2>
<H3>A.3.1 Primitive instantiation and instances</H3>
<A NAME="gate_instantiation" HREF="#Rgate_instantiation">gate_instantiation</A> ::=
 <A NAME="Rcmos_switchtype" HREF="#cmos_switchtype">cmos_switchtype</A> [delay3] <A NAME="Rcmos_switch_instance" HREF="#cmos_switch_instance">cmos_switch_instance</A> { , cmos_switch_instance } ;
 | <A NAME="Renable_gatetype" HREF="#enable_gatetype">enable_gatetype</A> [drive_strength] [delay3]
 <A NAME="Renable_gate_instance" HREF="#enable_gate_instance">enable_gate_instance</A> { , enable_gate_instance } ;
 | <A NAME="Rmos_switchtype" HREF="#mos_switchtype">mos_switchtype</A> [delay3] <A NAME="Rmos_switch_instance" HREF="#mos_switch_instance">mos_switch_instance</A> { , mos_switch_instance } ;
 | <A NAME="Rn_input_gatetype" HREF="#n_input_gatetype">n_input_gatetype</A> [drive_strength] [delay2]
 <A NAME="Rn_input_gate_instance" HREF="#n_input_gate_instance">n_input_gate_instance</A> { , n_input_gate_instance } ;
 | <A NAME="Rn_output_gatetype" HREF="#n_output_gatetype">n_output_gatetype</A> [drive_strength] [delay2]
 <A NAME="Rn_output_gate_instance" HREF="#n_output_gate_instance">n_output_gate_instance</A> { , n_output_gate_instance } ;
 | <A NAME="Rpass_en_switchtype" HREF="#pass_en_switchtype">pass_en_switchtype</A> [delay2]
 <A NAME="Rpass_enable_switch_instance" HREF="#pass_enable_switch_instance">pass_enable_switch_instance</A> { , pass_enable_switch_instance } ;
 | <A NAME="Rpass_switchtype" HREF="#pass_switchtype">pass_switchtype</A> <A NAME="Rpass_switch_instance" HREF="#pass_switch_instance">pass_switch_instance</A> { , pass_switch_instance } ;
 | pulldown [<A NAME="Rpulldown_strength" HREF="#pulldown_strength">pulldown_strength</A>] <A NAME="Rpull_gate_instance" HREF="#pull_gate_instance">pull_gate_instance</A> { , pull_gate_instance } ;
 | pullup [<A NAME="Rpullup_strength" HREF="#pullup_strength">pullup_strength</A>] pull_gate_instance { , pull_gate_instance } ;

<A NAME="cmos_switch_instance" HREF="#Rcmos_switch_instance">cmos_switch_instance</A> ::= [ <A NAME="Rname_of_gate_instance" HREF="#name_of_gate_instance">name_of_gate_instance</A> ] ( <A NAME="Routput_terminal" HREF="#output_terminal">output_terminal</A> ,
<A NAME="Rinput_terminal" HREF="#input_terminal">input_terminal</A> , <A NAME="Rncontrol_terminal" HREF="#ncontrol_terminal">ncontrol_terminal</A> , <A NAME="Rpcontrol_terminal" HREF="#pcontrol_terminal">pcontrol_terminal</A> )

<A NAME="enable_gate_instance" HREF="#Renable_gate_instance">enable_gate_instance</A> ::= [ name_of_gate_instance ] ( output_terminal ,
input_terminal , <A NAME="Renable_terminal" HREF="#enable_terminal">enable_terminal</A> )

<A NAME="mos_switch_instance" HREF="#Rmos_switch_instance">mos_switch_instance</A> ::= [ name_of_gate_instance ] ( output_terminal ,
input_terminal , enable_terminal )

<A NAME="n_input_gate_instance" HREF="#Rn_input_gate_instance">n_input_gate_instance</A> ::= [ name_of_gate_instance ] ( output_terminal ,
input_terminal { , input_terminal } )

<A NAME="n_output_gate_instance" HREF="#Rn_output_gate_instance">n_output_gate_instance</A> ::= [ name_of_gate_instance ] ( output_terminal
{ , output_terminal } , input_terminal )

<A NAME="pass_switch_instance" HREF="#Rpass_switch_instance">pass_switch_instance</A> ::= [ name_of_gate_instance ] ( <A NAME="Rinout_terminal" HREF="#inout_terminal">inout_terminal</A> ,
inout_terminal )

<A NAME="pass_enable_switch_instance" HREF="#Rpass_enable_switch_instance">pass_enable_switch_instance</A> ::= [ name_of_gate_instance ] ( inout_terminal ,
inout_terminal , enable_terminal )

<A NAME="pull_gate_instance" HREF="#Rpull_gate_instance">pull_gate_instance</A> ::= [ name_of_gate_instance ] ( output_terminal )

<A NAME="name_of_gate_instance" HREF="#Rname_of_gate_instance">name_of_gate_instance</A> ::= <A NAME="Rgate_instance_identifier" HREF="#gate_instance_identifier">gate_instance_identifier</A> [ range ]

<H3>A.3.2 Primitive strengths</H3>
<A NAME="pulldown_strength" HREF="#Rpulldown_strength">pulldown_strength</A> ::=
 ( strength0 , strength1 )
 | ( strength1 , strength0 )
 | ( strength0 )

<A NAME="pullup_strength" HREF="#Rpullup_strength">pullup_strength</A> ::=
 ( strength0 , strength1 )
 | ( strength1 , strength0 )
 | ( strength1 )

<H3>A.3.3 Primitive terminals</H3>
<A NAME="enable_terminal" HREF="#Renable_terminal">enable_terminal</A> ::= expression

<A NAME="inout_terminal" HREF="#Rinout_terminal">inout_terminal</A> ::= <A NAME="Rnet_lvalue" HREF="#net_lvalue">net_lvalue</A>

<A NAME="input_terminal" HREF="#Rinput_terminal">input_terminal</A> ::= expression

<A NAME="ncontrol_terminal" HREF="#Rncontrol_terminal">ncontrol_terminal</A> ::= expression

<A NAME="output_terminal" HREF="#Routput_terminal">output_terminal</A> ::= net_lvalue

<A NAME="pcontrol_terminal" HREF="#Rpcontrol_terminal">pcontrol_terminal</A> ::= expression

<H3>A.3.4 Primitive gate and switch types</H3>
<A NAME="cmos_switchtype" HREF="#Rcmos_switchtype">cmos_switchtype</A> ::= cmos | rcmos

<A NAME="enable_gatetype" HREF="#Renable_gatetype">enable_gatetype</A> ::= bufif0 | bufif1 | notif0 | notif1

<A NAME="mos_switchtype" HREF="#Rmos_switchtype">mos_switchtype</A> ::= nmos | pmos | rnmos | rpmos

<A NAME="n_input_gatetype" HREF="#Rn_input_gatetype">n_input_gatetype</A> ::= and | nand | or | nor | xor | xnor

<A NAME="n_output_gatetype" HREF="#Rn_output_gatetype">n_output_gatetype</A> ::= buf | not

<A NAME="pass_en_switchtype" HREF="#Rpass_en_switchtype">pass_en_switchtype</A> ::= tranif0 | tranif1 | rtranif1 | rtranif0

<A NAME="pass_switchtype" HREF="#Rpass_switchtype">pass_switchtype</A> ::= tran | rtran

<H2>A.4 Module and generated instantiation</H2>
<H3>A.4.1 Module instantiation</H3>
<A NAME="module_instantiation" HREF="#Rmodule_instantiation">module_instantiation</A> ::=
module_identifier [ <A NAME="Rparameter_value_assignment" HREF="#parameter_value_assignment">parameter_value_assignment</A> ]
<A NAME="Rmodule_instance" HREF="#module_instance">module_instance</A> { , module_instance } ;

<A NAME="parameter_value_assignment" HREF="#Rparameter_value_assignment">parameter_value_assignment</A> ::= # ( <A NAME="Rlist_of_parameter_assignments" HREF="#list_of_parameter_assignments">list_of_parameter_assignments</A> )

<A NAME="list_of_parameter_assignments" HREF="#Rlist_of_parameter_assignments">list_of_parameter_assignments</A> ::=
<A NAME="Rordered_parameter_assignment" HREF="#ordered_parameter_assignment">ordered_parameter_assignment</A> { , ordered_parameter_assignment }
| <A NAME="Rnamed_parameter_assignment" HREF="#named_parameter_assignment">named_parameter_assignment</A> { , named_parameter_assignment }

<A NAME="ordered_parameter_assignment" HREF="#Rordered_parameter_assignment">ordered_parameter_assignment</A> ::= expression

<A NAME="named_parameter_assignment" HREF="#Rnamed_parameter_assignment">named_parameter_assignment</A> ::= . parameter_identifier ( [ expression ] )

<A NAME="module_instance" HREF="#Rmodule_instance">module_instance</A> ::= <A NAME="Rname_of_instance" HREF="#name_of_instance">name_of_instance</A> ( [ <A NAME="Rlist_of_port_connections" HREF="#list_of_port_connections">list_of_port_connections</A> ] )

<A NAME="name_of_instance" HREF="#Rname_of_instance">name_of_instance</A> ::= <A NAME="Rmodule_instance_identifier" HREF="#module_instance_identifier">module_instance_identifier</A> [ range ]

<A NAME="list_of_port_connections" HREF="#Rlist_of_port_connections">list_of_port_connections</A> ::=
<A NAME="Rordered_port_connection" HREF="#ordered_port_connection">ordered_port_connection</A> { , ordered_port_connection }
| <A NAME="Rnamed_port_connection" HREF="#named_port_connection">named_port_connection</A> { , named_port_connection }

<A NAME="ordered_port_connection" HREF="#Rordered_port_connection">ordered_port_connection</A> ::= { attribute_instance } [ expression ]

<A NAME="named_port_connection" HREF="#Rnamed_port_connection">named_port_connection</A> ::= { attribute_instance } . port_identifier ([ expression ])

<H3>A.4.2 Generated instantiation</H3>
<A NAME="generated_instantiation" HREF="#Rgenerated_instantiation">generated_instantiation</A> ::= generate { <A NAME="Rgenerate_item" HREF="#generate_item">generate_item</A> } endgenerate

<A NAME="generate_item_or_null" HREF="#Rgenerate_item_or_null">generate_item_or_null</A> ::= generate_item | ;

<A NAME="generate_item" HREF="#Rgenerate_item">generate_item</A> ::=
 <A NAME="Rgenerate_conditional_statement" HREF="#generate_conditional_statement">generate_conditional_statement</A>
 | <A NAME="Rgenerate_case_statement" HREF="#generate_case_statement">generate_case_statement</A>
 | <A NAME="Rgenerate_loop_statement" HREF="#generate_loop_statement">generate_loop_statement</A>
 | <A NAME="Rgenerate_block" HREF="#generate_block">generate_block</A>
 | module_or_generate_item

<A NAME="generate_conditional_statement" HREF="#Rgenerate_conditional_statement">generate_conditional_statement</A> ::=
if ( constant_expression ) generate_item_or_null [ else generate_item_or_null ]

<A NAME="generate_case_statement" HREF="#Rgenerate_case_statement">generate_case_statement</A> ::= case ( constant_expression )
<A NAME="Rgenvar_case_item" HREF="#genvar_case_item">genvar_case_item</A> { genvar_case_item } endcase

<A NAME="genvar_case_item" HREF="#Rgenvar_case_item">genvar_case_item</A> ::= constant_expression { , constant_expression } :
generate_item_or_null | default [ : ] generate_item_or_null

<A NAME="generate_loop_statement" HREF="#Rgenerate_loop_statement">generate_loop_statement</A> ::=
for ( <A NAME="Rgenvar_assignment" HREF="#genvar_assignment">genvar_assignment</A> ; constant_expression ; genvar_assignment )
begin : <A NAME="Rgenerate_block_identifier" HREF="#generate_block_identifier">generate_block_identifier</A> { generate_item } end

<A NAME="genvar_assignment" HREF="#Rgenvar_assignment">genvar_assignment</A> ::= genvar_identifier = constant_expression

<A NAME="generate_block" HREF="#Rgenerate_block">generate_block</A> ::= begin [ : generate_block_identifier ] { generate_item } end

<H2>A.5 UDP declaration and instantiation</H2>
<H3>A.5.1 UDP declaration</H3>
<A NAME="udp_declaration" HREF="#Rudp_declaration">udp_declaration</A> ::=
 { attribute_instance } primitive <A NAME="Rudp_identifier" HREF="#udp_identifier">udp_identifier</A> ( <A NAME="Rudp_port_list" HREF="#udp_port_list">udp_port_list</A> ) ;
 <A NAME="Rudp_port_declaration" HREF="#udp_port_declaration">udp_port_declaration</A> { udp_port_declaration }
 <A NAME="Rudp_body" HREF="#udp_body">udp_body</A>
 endprimitive
 | { attribute_instance } primitive udp_identifier ( <A NAME="Rudp_declaration_port_list" HREF="#udp_declaration_port_list">udp_declaration_port_list</A> ) ;
 udp_body
 endprimitive

<H3>A.5.2 UDP ports</H3>
<A NAME="udp_port_list" HREF="#Rudp_port_list">udp_port_list</A> ::=
<A NAME="Routput_port_identifier" HREF="#output_port_identifier">output_port_identifier</A> , <A NAME="Rinput_port_identifier" HREF="#input_port_identifier">input_port_identifier</A> { , input_port_identifier }

<A NAME="udp_declaration_port_list" HREF="#Rudp_declaration_port_list">udp_declaration_port_list</A> ::=
<A NAME="Rudp_output_declaration" HREF="#udp_output_declaration">udp_output_declaration</A> , <A NAME="Rudp_input_declaration" HREF="#udp_input_declaration">udp_input_declaration</A> { , udp_input_declaration }

<A NAME="udp_port_declaration" HREF="#Rudp_port_declaration">udp_port_declaration</A> ::=
 udp_output_declaration ;
 | udp_input_declaration ;
 | <A NAME="Rudp_reg_declaration" HREF="#udp_reg_declaration">udp_reg_declaration</A> ;

<A NAME="udp_output_declaration" HREF="#Rudp_output_declaration">udp_output_declaration</A> ::=
{ attribute_instance } output port_identifier
| { attribute_instance } output reg port_identifier [ = constant_expression ]

<A NAME="udp_input_declaration" HREF="#Rudp_input_declaration">udp_input_declaration</A> ::= { attribute_instance } input list_of_port_identifiers

<A NAME="udp_reg_declaration" HREF="#Rudp_reg_declaration">udp_reg_declaration</A> ::= { attribute_instance } reg variable_identifier

<H3>A.5.3 UDP body</H3>
<A NAME="udp_body" HREF="#Rudp_body">udp_body</A> ::= <A NAME="Rcombinational_body" HREF="#combinational_body">combinational_body</A> | <A NAME="Rsequential_body" HREF="#sequential_body">sequential_body</A>

<A NAME="combinational_body" HREF="#Rcombinational_body">combinational_body</A> ::= table <A NAME="Rcombinational_entry" HREF="#combinational_entry">combinational_entry</A> { combinational_entry } endtable

<A NAME="combinational_entry" HREF="#Rcombinational_entry">combinational_entry</A> ::= <A NAME="Rlevel_input_list" HREF="#level_input_list">level_input_list</A> : <A NAME="Routput_symbol" HREF="#output_symbol">output_symbol</A> ;

<A NAME="sequential_body" HREF="#Rsequential_body">sequential_body</A> ::= [ <A NAME="Rudp_initial_statement" HREF="#udp_initial_statement">udp_initial_statement</A> ] table <A NAME="Rsequential_entry" HREF="#sequential_entry">sequential_entry</A>
{ sequential_entry } endtable

<A NAME="udp_initial_statement" HREF="#Rudp_initial_statement">udp_initial_statement</A> ::= initial output_port_identifier = <A NAME="Rinit_val" HREF="#init_val">init_val</A> ;

<A NAME="init_val" HREF="#Rinit_val">init_val</A> ::= 1'b0 | 1'b1 | 1'bx | 1'bX | 1'B0 | 1'B1 | 1'Bx | 1'BX | 1 | 0

<A NAME="sequential_entry" HREF="#Rsequential_entry">sequential_entry</A> ::= <A NAME="Rseq_input_list" HREF="#seq_input_list">seq_input_list</A> : <A NAME="Rcurrent_state" HREF="#current_state">current_state</A> : <A NAME="Rnext_state" HREF="#next_state">next_state</A> ;

<A NAME="seq_input_list" HREF="#Rseq_input_list">seq_input_list</A> ::= level_input_list | <A NAME="Redge_input_list" HREF="#edge_input_list">edge_input_list</A>

<A NAME="level_input_list" HREF="#Rlevel_input_list">level_input_list</A> ::= <A NAME="Rlevel_symbol" HREF="#level_symbol">level_symbol</A> { level_symbol }

<A NAME="edge_input_list" HREF="#Redge_input_list">edge_input_list</A> ::= { level_symbol } <A NAME="Redge_indicator" HREF="#edge_indicator">edge_indicator</A> { level_symbol }

<A NAME="edge_indicator" HREF="#Redge_indicator">edge_indicator</A> ::= ( level_symbol level_symbol ) | <A NAME="Redge_symbol" HREF="#edge_symbol">edge_symbol</A>

<A NAME="current_state" HREF="#Rcurrent_state">current_state</A> ::= level_symbol

<A NAME="next_state" HREF="#Rnext_state">next_state</A> ::= output_symbol | -

<A NAME="output_symbol" HREF="#Routput_symbol">output_symbol</A> ::= 0 | 1 | x | X

<A NAME="level_symbol" HREF="#Rlevel_symbol">level_symbol</A> ::= 0 | 1 | x | X | ? | b | B

<A NAME="edge_symbol" HREF="#Redge_symbol">edge_symbol</A> ::= r | R | f | F | p | P | n | N | *

<H3>A.5.4 UDP instantiation</H3>
<A NAME="udp_instantiation" HREF="#Rudp_instantiation">udp_instantiation</A> ::=
udp_identifier [ drive_strength ] [ delay2 ] <A NAME="Rudp_instance" HREF="#udp_instance">udp_instance</A> { , udp_instance } ;

<A NAME="udp_instance" HREF="#Rudp_instance">udp_instance</A> ::=
[ <A NAME="Rname_of_udp_instance" HREF="#name_of_udp_instance">name_of_udp_instance</A> ] ( output_terminal , input_terminal {, input_terminal} )

<A NAME="name_of_udp_instance" HREF="#Rname_of_udp_instance">name_of_udp_instance</A> ::= <A NAME="Rudp_instance_identifier" HREF="#udp_instance_identifier">udp_instance_identifier</A> [ range ]

<H2>A.6 Behavioral statements</H2>
<H3>A.6.1 Continuous assignment statements</H3>
<A NAME="continuous_assign" HREF="#Rcontinuous_assign">continuous_assign</A> ::= assign [ drive_strength ] [ delay3 ] <A NAME="Rlist_of_net_assignments" HREF="#list_of_net_assignments">list_of_net_assignments</A> ;

<A NAME="list_of_net_assignments" HREF="#Rlist_of_net_assignments">list_of_net_assignments</A> ::= <A NAME="Rnet_assignment" HREF="#net_assignment">net_assignment</A> { , net_assignment }

<A NAME="net_assignment" HREF="#Rnet_assignment">net_assignment</A> ::= net_lvalue = expression

<H3>A.6.2 Procedural blocks and assignments</H3>
<A NAME="initial_construct" HREF="#Rinitial_construct">initial_construct</A> ::= initial statement

<A NAME="always_construct" HREF="#Ralways_construct">always_construct</A> ::= always statement

<A NAME="blocking_assignment" HREF="#Rblocking_assignment">blocking_assignment</A> ::= <A NAME="Rvariable_lvalue" HREF="#variable_lvalue">variable_lvalue</A> = [ <A NAME="Rdelay_or_event_control" HREF="#delay_or_event_control">delay_or_event_control</A> ] expression

<A NAME="nonblocking_assignment" HREF="#Rnonblocking_assignment">nonblocking_assignment</A> ::= variable_lvalue <= [ delay_or_event_control ] expression

<A NAME="procedural_continuous_assignments" HREF="#Rprocedural_continuous_assignments">procedural_continuous_assignments</A> ::=
 assign <A NAME="Rvariable_assignment" HREF="#variable_assignment">variable_assignment</A>
 | deassign variable_lvalue
 | force variable_assignment
 | force net_assignment
 | release variable_lvalue
 | release net_lvalue

<A NAME="function_blocking_assignment" HREF="#Rfunction_blocking_assignment">function_blocking_assignment</A> ::= variable_lvalue = expression

<A NAME="function_statement_or_null" HREF="#Rfunction_statement_or_null">function_statement_or_null</A> ::=
function_statement
| { attribute_instance } ;

<H3>A.6.3 Parallel and sequential blocks</H3>
<A NAME="function_seq_block" HREF="#Rfunction_seq_block">function_seq_block</A> ::= begin [ : <A NAME="Rblock_identifier" HREF="#block_identifier">block_identifier</A>
{ block_item_declaration } ] { function_statement } end

<A NAME="variable_assignment" HREF="#Rvariable_assignment">variable_assignment</A> ::= variable_lvalue = expression

<A NAME="par_block" HREF="#Rpar_block">par_block</A> ::= fork [ : block_identifier
{ block_item_declaration } ] { statement } join

<A NAME="seq_block" HREF="#Rseq_block">seq_block</A> ::= begin [ : block_identifier
{ block_item_declaration } ] { statement } end

<H3>A.6.4 Statements</H3>
<A NAME="statement" HREF="#Rstatement">statement</A> ::=
 { attribute_instance } blocking_assignment ;
 | { attribute_instance } <A NAME="Rcase_statement" HREF="#case_statement">case_statement</A>
 | { attribute_instance } <A NAME="Rconditional_statement" HREF="#conditional_statement">conditional_statement</A>
 | { attribute_instance } <A NAME="Rdisable_statement" HREF="#disable_statement">disable_statement</A>
 | { attribute_instance } <A NAME="Revent_trigger" HREF="#event_trigger">event_trigger</A>
 | { attribute_instance } <A NAME="Rloop_statement" HREF="#loop_statement">loop_statement</A>
 | { attribute_instance } nonblocking_assignment ;
 | { attribute_instance } par_block
 | { attribute_instance } procedural_continuous_assignments ;
 | { attribute_instance } <A NAME="Rprocedural_timing_control_statement" HREF="#procedural_timing_control_statement">procedural_timing_control_statement</A>
 | { attribute_instance } seq_block
 | { attribute_instance } <A NAME="Rsystem_task_enable" HREF="#system_task_enable">system_task_enable</A>
 | { attribute_instance } <A NAME="Rtask_enable" HREF="#task_enable">task_enable</A>
 | { attribute_instance } <A NAME="Rwait_statement" HREF="#wait_statement">wait_statement</A>

<A NAME="statement_or_null" HREF="#Rstatement_or_null">statement_or_null</A> ::=
statement
| { attribute_instance } ;

<A NAME="function_statement" HREF="#Rfunction_statement">function_statement</A> ::=
 { attribute_instance } function_blocking_assignment ;
 | { attribute_instance } <A NAME="Rfunction_case_statement" HREF="#function_case_statement">function_case_statement</A>
 | { attribute_instance } <A NAME="Rfunction_conditional_statement" HREF="#function_conditional_statement">function_conditional_statement</A>
 | { attribute_instance } <A NAME="Rfunction_loop_statement" HREF="#function_loop_statement">function_loop_statement</A>
 | { attribute_instance } function_seq_block
 | { attribute_instance } disable_statement
 | { attribute_instance } system_task_enable

<H3>A.6.5 Timing control statements</H3>
<A NAME="delay_control" HREF="#Rdelay_control">delay_control</A> ::=
# delay_value
| # ( mintypmax_expression )

<A NAME="delay_or_event_control" HREF="#Rdelay_or_event_control">delay_or_event_control</A> ::=
 delay_control
 | <A NAME="Revent_control" HREF="#event_control">event_control</A>
 | repeat ( expression ) event_control

<A NAME="disable_statement" HREF="#Rdisable_statement">disable_statement</A> ::=
disable <A NAME="Rhierarchical_task_identifier" HREF="#hierarchical_task_identifier">hierarchical_task_identifier</A> ;
| disable <A NAME="Rhierarchical_block_identifier" HREF="#hierarchical_block_identifier">hierarchical_block_identifier</A> ;

<A NAME="event_control" HREF="#Revent_control">event_control</A> ::=
 @ event_identifier
 | @ ( <A NAME="Revent_expression" HREF="#event_expression">event_expression</A> )
 | @ *
 | @ ( * )

<A NAME="event_trigger" HREF="#Revent_trigger">event_trigger</A> ::=
-> <A NAME="Rhierarchical_event_identifier" HREF="#hierarchical_event_identifier">hierarchical_event_identifier</A> ;

<A NAME="event_expression" HREF="#Revent_expression">event_expression</A> ::=
 expression
 | <A NAME="Rhierarchical_identifier" HREF="#hierarchical_identifier">hierarchical_identifier</A>
 | posedge expression
 | negedge expression
 | event_expression or event_expression
 | event_expression , event_expression

<A NAME="procedural_timing_control_statement" HREF="#Rprocedural_timing_control_statement">procedural_timing_control_statement</A> ::=
delay_or_event_control statement_or_null

<A NAME="wait_statement" HREF="#Rwait_statement">wait_statement</A> ::=
wait ( expression ) statement_or_null

<H3>A.6.6 Conditional statements</H3>
<A NAME="conditional_statement" HREF="#Rconditional_statement">conditional_statement</A> ::=
 if ( expression )
 statement_or_null [ else statement_or_null ]
 | <A NAME="Rif_else_if_statement" HREF="#if_else_if_statement">if_else_if_statement</A>

<A NAME="if_else_if_statement" HREF="#Rif_else_if_statement">if_else_if_statement</A> ::=
 if ( expression ) statement_or_null
 { else if ( expression ) statement_or_null }
 [ else statement_or_null ]

<A NAME="function_conditional_statement" HREF="#Rfunction_conditional_statement">function_conditional_statement</A> ::=
 if ( expression ) function_statement_or_null
 [ else function_statement_or_null ]
 | <A NAME="Rfunction_if_else_if_statement" HREF="#function_if_else_if_statement">function_if_else_if_statement</A>

<A NAME="function_if_else_if_statement" HREF="#Rfunction_if_else_if_statement">function_if_else_if_statement</A> ::=
 if ( expression ) function_statement_or_null
 { else if ( expression ) function_statement_or_null }
 [ else function_statement_or_null ]

<H3>A.6.7 Case statements</H3>
<A NAME="case_statement" HREF="#Rcase_statement">case_statement</A> ::=
 case ( expression )
 <A NAME="Rcase_item" HREF="#case_item">case_item</A> { case_item } endcase
 | casez ( expression )
 case_item { case_item } endcase
 | casex ( expression )
 case_item { case_item } endcase

<A NAME="case_item" HREF="#Rcase_item">case_item</A> ::=
expression { , expression } : statement_or_null
| default [ : ] statement_or_null

<A NAME="function_case_statement" HREF="#Rfunction_case_statement">function_case_statement</A> ::=
 case ( expression )
 <A NAME="Rfunction_case_item" HREF="#function_case_item">function_case_item</A> { function_case_item } endcase
 | casez ( expression )
 function_case_item { function_case_item } endcase
 | casex ( expression )
 function_case_item { function_case_item } endcase

<A NAME="function_case_item" HREF="#Rfunction_case_item">function_case_item</A> ::=
expression { , expression } : function_statement_or_null
| default [ : ] function_statement_or_null

<H3>A.6.8 Looping statements</H3>
<A NAME="function_loop_statement" HREF="#Rfunction_loop_statement">function_loop_statement</A> ::=
 forever function_statement
 | repeat ( expression ) function_statement
 | while ( expression ) function_statement
 | for ( variable_assignment ; expression ; variable_assignment )
 function_statement

<A NAME="loop_statement" HREF="#Rloop_statement">loop_statement</A> ::=
 forever statement
 | repeat ( expression ) statement
 | while ( expression ) statement
 | for ( variable_assignment ; expression ; variable_assignment )
 statement

<H3>A.6.9 Task enable statements</H3>
<A NAME="system_task_enable" HREF="#Rsystem_task_enable">system_task_enable</A> ::= <A NAME="Rsystem_task_identifier" HREF="#system_task_identifier">system_task_identifier</A> [ ( expression { , expression } ) ] ;

<A NAME="task_enable" HREF="#Rtask_enable">task_enable</A> ::= hierarchical_task_identifier [ ( expression { , expression } ) ] ;

<H2>A.7 Specify section</H2>
<H3>A.7.1 Specify block declaration</H3>
<A NAME="specify_block" HREF="#Rspecify_block">specify_block</A> ::= specify { <A NAME="Rspecify_item" HREF="#specify_item">specify_item</A> } endspecify

<A NAME="specify_item" HREF="#Rspecify_item">specify_item</A> ::=
 specparam_declaration
 | <A NAME="Rpulsestyle_declaration" HREF="#pulsestyle_declaration">pulsestyle_declaration</A>
 | <A NAME="Rshowcancelled_declaration" HREF="#showcancelled_declaration">showcancelled_declaration</A>
 | <A NAME="Rpath_declaration" HREF="#path_declaration">path_declaration</A>
 | <A NAME="Rsystem_timing_check" HREF="#system_timing_check">system_timing_check</A>

<A NAME="pulsestyle_declaration" HREF="#Rpulsestyle_declaration">pulsestyle_declaration</A> ::=
pulsestyle_onevent <A NAME="Rlist_of_path_outputs" HREF="#list_of_path_outputs">list_of_path_outputs</A> ;
| pulsestyle_ondetect list_of_path_outputs ;

<A NAME="showcancelled_declaration" HREF="#Rshowcancelled_declaration">showcancelled_declaration</A> ::=
showcancelled list_of_path_outputs ;
| noshowcancelled list_of_path_outputs ;

<H3>A.7.2 Specify path declarations</H3>
<A NAME="path_declaration" HREF="#Rpath_declaration">path_declaration</A> ::=
 <A NAME="Rsimple_path_declaration" HREF="#simple_path_declaration">simple_path_declaration</A> ;
 | <A NAME="Redge_sensitive_path_declaration" HREF="#edge_sensitive_path_declaration">edge_sensitive_path_declaration</A> ;
 | <A NAME="Rstate_dependent_path_declaration" HREF="#state_dependent_path_declaration">state_dependent_path_declaration</A> ;

<A NAME="simple_path_declaration" HREF="#Rsimple_path_declaration">simple_path_declaration</A> ::=
<A NAME="Rparallel_path_description" HREF="#parallel_path_description">parallel_path_description</A> = <A NAME="Rpath_delay_value" HREF="#path_delay_value">path_delay_value</A>
| <A NAME="Rfull_path_description" HREF="#full_path_description">full_path_description</A> = path_delay_value

<A NAME="parallel_path_description" HREF="#Rparallel_path_description">parallel_path_description</A> ::=
( specify_input_terminal_descriptor [ <A NAME="Rpolarity_operator" HREF="#polarity_operator">polarity_operator</A> ] =>
specify_output_terminal_descriptor )

<A NAME="full_path_description" HREF="#Rfull_path_description">full_path_description</A> ::=
( <A NAME="Rlist_of_path_inputs" HREF="#list_of_path_inputs">list_of_path_inputs</A> [ polarity_operator ] *> list_of_path_outputs )

<A NAME="list_of_path_inputs" HREF="#Rlist_of_path_inputs">list_of_path_inputs</A> ::=
specify_input_terminal_descriptor { , specify_input_terminal_descriptor }

<A NAME="list_of_path_outputs" HREF="#Rlist_of_path_outputs">list_of_path_outputs</A> ::=
specify_output_terminal_descriptor { , specify_output_terminal_descriptor }

<H3>A.7.3 Specify block terminals</H3>
<A NAME="specify_input_terminal_descriptor" HREF="#Rspecify_input_terminal_descriptor">specify_input_terminal_descriptor</A> ::=
 <A NAME="Rinput_identifier" HREF="#input_identifier">input_identifier</A>
 | input_identifier [ constant_expression ]
 | input_identifier [ range_expression ]

<A NAME="specify_output_terminal_descriptor" HREF="#Rspecify_output_terminal_descriptor">specify_output_terminal_descriptor</A> ::=
 <A NAME="Routput_identifier" HREF="#output_identifier">output_identifier</A>
 | output_identifier [ constant_expression ]
 | output_identifier [ range_expression ]

<A NAME="input_identifier" HREF="#Rinput_identifier">input_identifier</A> ::= input_port_identifier | <A NAME="Rinout_port_identifier" HREF="#inout_port_identifier">inout_port_identifier</A>

<A NAME="output_identifier" HREF="#Routput_identifier">output_identifier</A> ::= output_port_identifier | inout_port_identifier

<H3>A.7.4 Specify path delays</H3>
<A NAME="path_delay_value" HREF="#Rpath_delay_value">path_delay_value</A> ::=
<A NAME="Rlist_of_path_delay_expressions" HREF="#list_of_path_delay_expressions">list_of_path_delay_expressions</A>
| ( list_of_path_delay_expressions )

<A NAME="list_of_path_delay_expressions" HREF="#Rlist_of_path_delay_expressions">list_of_path_delay_expressions</A> ::=
 <A NAME="Rt_path_delay_expression" HREF="#t_path_delay_expression">t_path_delay_expression</A>
 | <A NAME="Rtrise_path_delay_expression" HREF="#trise_path_delay_expression">trise_path_delay_expression</A> , <A NAME="Rtfall_path_delay_expression" HREF="#tfall_path_delay_expression">tfall_path_delay_expression</A>
 | trise_path_delay_expression , tfall_path_delay_expression ,
 <A NAME="Rtz_path_delay_expression" HREF="#tz_path_delay_expression">tz_path_delay_expression</A>
 | <A NAME="Rt01_path_delay_expression" HREF="#t01_path_delay_expression">t01_path_delay_expression</A> , <A NAME="Rt10_path_delay_expression" HREF="#t10_path_delay_expression">t10_path_delay_expression</A> ,
 <A NAME="Rt0z_path_delay_expression" HREF="#t0z_path_delay_expression">t0z_path_delay_expression</A> , <A NAME="Rtz1_path_delay_expression" HREF="#tz1_path_delay_expression">tz1_path_delay_expression</A> ,
 <A NAME="Rt1z_path_delay_expression" HREF="#t1z_path_delay_expression">t1z_path_delay_expression</A> , <A NAME="Rtz0_path_delay_expression" HREF="#tz0_path_delay_expression">tz0_path_delay_expression</A>
 | t01_path_delay_expression , t10_path_delay_expression ,
 t0z_path_delay_expression , tz1_path_delay_expression ,
 t1z_path_delay_expression , tz0_path_delay_expression ,
 <A NAME="Rt0x_path_delay_expression" HREF="#t0x_path_delay_expression">t0x_path_delay_expression</A> , <A NAME="Rtx1_path_delay_expression" HREF="#tx1_path_delay_expression">tx1_path_delay_expression</A> ,
 <A NAME="Rt1x_path_delay_expression" HREF="#t1x_path_delay_expression">t1x_path_delay_expression</A> , <A NAME="Rtx0_path_delay_expression" HREF="#tx0_path_delay_expression">tx0_path_delay_expression</A> ,
 <A NAME="Rtxz_path_delay_expression" HREF="#txz_path_delay_expression">txz_path_delay_expression</A> , <A NAME="Rtzx_path_delay_expression" HREF="#tzx_path_delay_expression">tzx_path_delay_expression</A>

<A NAME="t_path_delay_expression" HREF="#Rt_path_delay_expression">t_path_delay_expression</A> ::= <A NAME="Rpath_delay_expression" HREF="#path_delay_expression">path_delay_expression</A>

<A NAME="trise_path_delay_expression" HREF="#Rtrise_path_delay_expression">trise_path_delay_expression</A> ::= path_delay_expression

<A NAME="tfall_path_delay_expression" HREF="#Rtfall_path_delay_expression">tfall_path_delay_expression</A> ::= path_delay_expression

<A NAME="tz_path_delay_expression" HREF="#Rtz_path_delay_expression">tz_path_delay_expression</A> ::= path_delay_expression

<A NAME="t01_path_delay_expression" HREF="#Rt01_path_delay_expression">t01_path_delay_expression</A> ::= path_delay_expression

<A NAME="t10_path_delay_expression" HREF="#Rt10_path_delay_expression">t10_path_delay_expression</A> ::= path_delay_expression

<A NAME="t0z_path_delay_expression" HREF="#Rt0z_path_delay_expression">t0z_path_delay_expression</A> ::= path_delay_expression

<A NAME="tz1_path_delay_expression" HREF="#Rtz1_path_delay_expression">tz1_path_delay_expression</A> ::= path_delay_expression

<A NAME="t1z_path_delay_expression" HREF="#Rt1z_path_delay_expression">t1z_path_delay_expression</A> ::= path_delay_expression

<A NAME="tz0_path_delay_expression" HREF="#Rtz0_path_delay_expression">tz0_path_delay_expression</A> ::= path_delay_expression

<A NAME="t0x_path_delay_expression" HREF="#Rt0x_path_delay_expression">t0x_path_delay_expression</A> ::= path_delay_expression

<A NAME="tx1_path_delay_expression" HREF="#Rtx1_path_delay_expression">tx1_path_delay_expression</A> ::= path_delay_expression

<A NAME="t1x_path_delay_expression" HREF="#Rt1x_path_delay_expression">t1x_path_delay_expression</A> ::= path_delay_expression

<A NAME="tx0_path_delay_expression" HREF="#Rtx0_path_delay_expression">tx0_path_delay_expression</A> ::= path_delay_expression

<A NAME="txz_path_delay_expression" HREF="#Rtxz_path_delay_expression">txz_path_delay_expression</A> ::= path_delay_expression

<A NAME="tzx_path_delay_expression" HREF="#Rtzx_path_delay_expression">tzx_path_delay_expression</A> ::= path_delay_expression

<A NAME="path_delay_expression" HREF="#Rpath_delay_expression">path_delay_expression</A> ::= constant_mintypmax_expression

<A NAME="edge_sensitive_path_declaration" HREF="#Redge_sensitive_path_declaration">edge_sensitive_path_declaration</A> ::=
<A NAME="Rparallel_edge_sensitive_path_description" HREF="#parallel_edge_sensitive_path_description">parallel_edge_sensitive_path_description</A> = path_delay_value
| <A NAME="Rfull_edge_sensitive_path_description" HREF="#full_edge_sensitive_path_description">full_edge_sensitive_path_description</A> = path_delay_value

<A NAME="parallel_edge_sensitive_path_description" HREF="#Rparallel_edge_sensitive_path_description">parallel_edge_sensitive_path_description</A> ::=
 ( [ <A NAME="Redge_identifier" HREF="#edge_identifier">edge_identifier</A> ] specify_input_terminal_descriptor =>
 specify_output_terminal_descriptor [ polarity_operator ] :
 <A NAME="Rdata_source_expression" HREF="#data_source_expression">data_source_expression</A> )

<A NAME="full_edge_sensitive_path_description" HREF="#Rfull_edge_sensitive_path_description">full_edge_sensitive_path_description</A> ::=
( [ edge_identifier ] list_of_path_inputs *>
list_of_path_outputs [ polarity_operator ] : data_source_expression )

<A NAME="data_source_expression" HREF="#Rdata_source_expression">data_source_expression</A> ::= expression

<A NAME="edge_identifier" HREF="#Redge_identifier">edge_identifier</A> ::= posedge | negedge

<A NAME="state_dependent_path_declaration" HREF="#Rstate_dependent_path_declaration">state_dependent_path_declaration</A> ::=
 if ( <A NAME="Rmodule_path_expression" HREF="#module_path_expression">module_path_expression</A> ) simple_path_declaration
 | if ( module_path_expression ) edge_sensitive_path_declaration
 | ifnone simple_path_declaration

<A NAME="polarity_operator" HREF="#Rpolarity_operator">polarity_operator</A> ::= + | -

<H3>A.7.5 System timing checks</H3>
<H4>A.7.5.1 System timing check commands</H4>
<A NAME="system_timing_check" HREF="#Rsystem_timing_check">system_timing_check</A> ::=
 <A NAME="R$setup_timing_check" HREF="#$setup_timing_check">$setup_timing_check</A>
 | <A NAME="R$hold_timing_check" HREF="#$hold_timing_check">$hold_timing_check</A>
 | <A NAME="R$setuphold_timing_check" HREF="#$setuphold_timing_check">$setuphold_timing_check</A>
 | <A NAME="R$recovery_timing_check" HREF="#$recovery_timing_check">$recovery_timing_check</A>
 | <A NAME="R$removal_timing_check" HREF="#$removal_timing_check">$removal_timing_check</A>
 | <A NAME="R$recrem_timing_check" HREF="#$recrem_timing_check">$recrem_timing_check</A>
 | <A NAME="R$skew_timing_check" HREF="#$skew_timing_check">$skew_timing_check</A>
 | <A NAME="R$timeskew_timing_check" HREF="#$timeskew_timing_check">$timeskew_timing_check</A>
 | <A NAME="R$fullskew_timing_check" HREF="#$fullskew_timing_check">$fullskew_timing_check</A>
 | <A NAME="R$period_timing_check" HREF="#$period_timing_check">$period_timing_check</A>
 | <A NAME="R$width_timing_check" HREF="#$width_timing_check">$width_timing_check</A>
 | <A NAME="R$nochange_timing_check" HREF="#$nochange_timing_check">$nochange_timing_check</A>

<A NAME="$setup_timing_check" HREF="#R$setup_timing_check">$setup_timing_check</A> ::=
$setup ( <A NAME="Rdata_event" HREF="#data_event">data_event</A> , <A NAME="Rreference_event" HREF="#reference_event">reference_event</A> , <A NAME="Rtiming_check_limit" HREF="#timing_check_limit">timing_check_limit</A> [,[ <A NAME="Rnotify_reg" HREF="#notify_reg">notify_reg</A> ]] ) ;

<A NAME="$hold_timing_check" HREF="#R$hold_timing_check">$hold_timing_check</A> ::=
$hold ( reference_event , data_event , timing_check_limit [, [ notify_reg ]] ) ;

<A NAME="$setuphold_timing_check" HREF="#R$setuphold_timing_check">$setuphold_timing_check</A> ::=
 $setuphold (
 reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notify_reg ] [ , [ <A NAME="Rstamptime_condition" HREF="#stamptime_condition">stamptime_condition</A> ] [ , [ <A NAME="Rchecktime_condition" HREF="#checktime_condition">checktime_condition</A> ]
 [ , [ <A NAME="Rdelayed_reference" HREF="#delayed_reference">delayed_reference</A> ] [ , [ <A NAME="Rdelayed_data" HREF="#delayed_data">delayed_data</A> ] ] ] ] ] ] ) ;

<A NAME="$recovery_timing_check" HREF="#R$recovery_timing_check">$recovery_timing_check</A> ::=
$recovery ( reference_event , data_event , timing_check_limit [,[notify_reg]]) ;

<A NAME="$removal_timing_check" HREF="#R$removal_timing_check">$removal_timing_check</A> ::=
$removal ( reference_event , data_event , timing_check_limit [ , notify_reg]]) ;

<A NAME="$recrem_timing_check" HREF="#R$recrem_timing_check">$recrem_timing_check</A> ::=
 $recrem (
 reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notify_reg ] [ , [ stamptime_condition ] [ , [ checktime_condition ]
 [ , [ delayed_reference ] [ , [ delayed_data ] ] ] ] ] ] ) ;

<A NAME="$skew_timing_check" HREF="#R$skew_timing_check">$skew_timing_check</A> ::=
$skew ( reference_event , data_event , timing_check_limit [ , [ notify_reg ]]) ;

<A NAME="$timeskew_timing_check" HREF="#R$timeskew_timing_check">$timeskew_timing_check</A> ::=
$timeskew ( reference_event , data_event , timing_check_limit
[ , [ notify_reg ] [ , [ <A NAME="Revent_based_flag" HREF="#event_based_flag">event_based_flag</A> ] [ , [ <A NAME="Rremain_active_flag" HREF="#remain_active_flag">remain_active_flag</A> ]] ]] ) ;

<A NAME="$fullskew_timing_check" HREF="#R$fullskew_timing_check">$fullskew_timing_check</A> ::=
 $fullskew (
 reference_event , data_event , timing_check_limit , timing_check_limit
 [ , [ notify_reg ] [ , [ event_based_flag ] [ , [ remain_active_flag ]] ]] ) ;

<A NAME="$period_timing_check" HREF="#R$period_timing_check">$period_timing_check</A> ::=
$period ( <A NAME="Rcontrolled_reference_event" HREF="#controlled_reference_event">controlled_reference_event</A> , timing_check_limit [, [ notify_reg ]] ) ;

<A NAME="$width_timing_check" HREF="#R$width_timing_check">$width_timing_check</A> ::=
$width ( controlled_reference_event , timing_check_limit ,
<A NAME="Rthreshold" HREF="#threshold">threshold</A> [ , [ notify_reg ] ] ) ;

<A NAME="$nochange_timing_check" HREF="#R$nochange_timing_check">$nochange_timing_check</A> ::=
$nochange ( reference_event , data_event , <A NAME="Rstart_edge_offset" HREF="#start_edge_offset">start_edge_offset</A> ,
<A NAME="Rend_edge_offset" HREF="#end_edge_offset">end_edge_offset</A> [ , [ notify_reg ] ] ) ;

<H4>A.7.5.2 System timing check command arguments</H4>
<A NAME="checktime_condition" HREF="#Rchecktime_condition">checktime_condition</A> ::= mintypmax_expression

<A NAME="controlled_reference_event" HREF="#Rcontrolled_reference_event">controlled_reference_event</A> ::= <A NAME="Rcontrolled_timing_check_event" HREF="#controlled_timing_check_event">controlled_timing_check_event</A>

<A NAME="data_event" HREF="#Rdata_event">data_event</A> ::= <A NAME="Rtiming_check_event" HREF="#timing_check_event">timing_check_event</A>

<A NAME="delayed_data" HREF="#Rdelayed_data">delayed_data</A> ::=
<A NAME="Rterminal_identifier" HREF="#terminal_identifier">terminal_identifier</A>
| terminal_identifier [ constant_mintypmax_expression ]

<A NAME="delayed_reference" HREF="#Rdelayed_reference">delayed_reference</A> ::=
terminal_identifier
| terminal_identifier [ constant_mintypmax_expression ]

<A NAME="end_edge_offset" HREF="#Rend_edge_offset">end_edge_offset</A> ::= mintypmax_expression

<A NAME="event_based_flag" HREF="#Revent_based_flag">event_based_flag</A> ::= constant_expression

<A NAME="notify_reg" HREF="#Rnotify_reg">notify_reg</A> ::= variable_identifier

<A NAME="reference_event" HREF="#Rreference_event">reference_event</A> ::= timing_check_event

<A NAME="remain_active_flag" HREF="#Rremain_active_flag">remain_active_flag</A> ::= constant_mintypmax_expression

<A NAME="stamptime_condition" HREF="#Rstamptime_condition">stamptime_condition</A> ::= mintypmax_expression

<A NAME="start_edge_offset" HREF="#Rstart_edge_offset">start_edge_offset</A> ::= mintypmax_expression

<A NAME="threshold" HREF="#Rthreshold">threshold</A> ::=constant_expression

<A NAME="timing_check_limit" HREF="#Rtiming_check_limit">timing_check_limit</A> ::= expression

<H4>A.7.5.3 System timing check event definitions</H4>
<A NAME="timing_check_event" HREF="#Rtiming_check_event">timing_check_event</A> ::=
[ <A NAME="Rtiming_check_event_control" HREF="#timing_check_event_control">timing_check_event_control</A> ] <A NAME="Rspecify_terminal_descriptor" HREF="#specify_terminal_descriptor">specify_terminal_descriptor</A>
[ &&& <A NAME="Rtiming_check_condition" HREF="#timing_check_condition">timing_check_condition</A> ]

<A NAME="controlled_timing_check_event" HREF="#Rcontrolled_timing_check_event">controlled_timing_check_event</A> ::=
timing_check_event_control specify_terminal_descriptor
[ &&& timing_check_condition ]

<A NAME="timing_check_event_control" HREF="#Rtiming_check_event_control">timing_check_event_control</A> ::=
 posedge
 | negedge
 | <A NAME="Redge_control_specifier" HREF="#edge_control_specifier">edge_control_specifier</A>

<A NAME="specify_terminal_descriptor" HREF="#Rspecify_terminal_descriptor">specify_terminal_descriptor</A> ::=
specify_input_terminal_descriptor
| specify_output_terminal_descriptor

<A NAME="edge_control_specifier" HREF="#Redge_control_specifier">edge_control_specifier</A> ::= edge [ <A NAME="Redge_descriptor" HREF="#edge_descriptor">edge_descriptor</A> { , edge_descriptor } ]

<A NAME="edge_descriptor" HREF="#Redge_descriptor">edge_descriptor</A><A NAME="RNote1" HREF="#Note1">1</A> ::=
 01
 | 10
 | <A NAME="Rz_or_x" HREF="#z_or_x">z_or_x</A> <A NAME="Rzero_or_one" HREF="#zero_or_one">zero_or_one</A>
 | zero_or_one z_or_x

<A NAME="zero_or_one" HREF="#Rzero_or_one">zero_or_one</A> ::= 0 | 1

<A NAME="z_or_x" HREF="#Rz_or_x">z_or_x</A> ::= x | X | z | Z

<A NAME="timing_check_condition" HREF="#Rtiming_check_condition">timing_check_condition</A> ::=
<A NAME="Rscalar_timing_check_condition" HREF="#scalar_timing_check_condition">scalar_timing_check_condition</A>
| ( scalar_timing_check_condition )

<A NAME="scalar_timing_check_condition" HREF="#Rscalar_timing_check_condition">scalar_timing_check_condition</A> ::=
 expression
 | ~ expression
 | expression == <A NAME="Rscalar_constant" HREF="#scalar_constant">scalar_constant</A>
 | expression === scalar_constant
 | expression != scalar_constant
 | expression !== scalar_constant

<A NAME="scalar_constant" HREF="#Rscalar_constant">scalar_constant</A> ::=
1'b0 | 1'b1 | 1'B0 | 1'B1 | 'b0 | 'b1 | 'B0 | 'B1 | 1 | 0

<H2>A.8 Expressions</H2>
<H3>A.8.1 Concatenations</H3>
<A NAME="concatenation" HREF="#Rconcatenation">concatenation</A> ::= { expression { , expression } }

<A NAME="constant_concatenation" HREF="#Rconstant_concatenation">constant_concatenation</A> ::= { constant_expression { , constant_expression } }

<A NAME="constant_multiple_concatenation" HREF="#Rconstant_multiple_concatenation">constant_multiple_concatenation</A> ::= { constant_expression constant_concatenation }

<A NAME="module_path_concatenation" HREF="#Rmodule_path_concatenation">module_path_concatenation</A> ::= { module_path_expression {, module_path_expression } }

<A NAME="module_path_multiple_concatenation" HREF="#Rmodule_path_multiple_concatenation">module_path_multiple_concatenation</A> ::=
{ constant_expression module_path_concatenation }

<A NAME="multiple_concatenation" HREF="#Rmultiple_concatenation">multiple_concatenation</A> ::= { constant_expression concatenation }

<A NAME="net_concatenation" HREF="#Rnet_concatenation">net_concatenation</A> ::= { <A NAME="Rnet_concatenation_value" HREF="#net_concatenation_value">net_concatenation_value</A> { , net_concatenation_value } }

<A NAME="net_concatenation_value" HREF="#Rnet_concatenation_value">net_concatenation_value</A> ::=
 <A NAME="Rhierarchical_net_identifier" HREF="#hierarchical_net_identifier">hierarchical_net_identifier</A>
 | hierarchical_net_identifier [ expression ] {[ expression ]}
 | hierarchical_net_identifier [ expression ] {[ expression ]} [ range_expression ]
 | hierarchical_net_identifier [ range_expression ]
 | net_concatenation

<A NAME="variable_concatenation" HREF="#Rvariable_concatenation">variable_concatenation</A> ::=
{ <A NAME="Rvariable_concatenation_value" HREF="#variable_concatenation_value">variable_concatenation_value</A> { , variable_concatenation_value } }

<A NAME="variable_concatenation_value" HREF="#Rvariable_concatenation_value">variable_concatenation_value</A> ::=
 <A NAME="Rhierarchical_variable_identifier" HREF="#hierarchical_variable_identifier">hierarchical_variable_identifier</A>
 | hierarchical_variable_identifier [ expression ] { [ expression ] }
 | hierarchical_variable_identifier [ expression ] { [ expression ] }
 [ range_expression ]
 | hierarchical_variable_identifier [ range_expression ]
 | variable_concatenation

<H3>A.8.2 Function calls</H3>
<A NAME="constant_function_call" HREF="#Rconstant_function_call">constant_function_call</A> ::= function_identifier { attribute_instance }
( constant_expression { , constant_expression } )

<A NAME="function_call" HREF="#Rfunction_call">function_call</A> ::= <A NAME="Rhierarchical_function_identifier" HREF="#hierarchical_function_identifier">hierarchical_function_identifier</A>{ attribute_instance }
( expression { , expression } )

<A NAME="system_function_call" HREF="#Rsystem_function_call">system_function_call</A> ::= <A NAME="Rsystem_function_identifier" HREF="#system_function_identifier">system_function_identifier</A> [ ( expression {, expression} )]

<H3>A.8.3 Expressions</H3>
<A NAME="base_expression" HREF="#Rbase_expression">base_expression</A> ::= expression

<A NAME="conditional_expression" HREF="#Rconditional_expression">conditional_expression</A> ::=
<A NAME="Rexpression1" HREF="#expression1">expression1</A> ? { attribute_instance } <A NAME="Rexpression2" HREF="#expression2">expression2</A> : <A NAME="Rexpression3" HREF="#expression3">expression3</A>

<A NAME="constant_base_expression" HREF="#Rconstant_base_expression">constant_base_expression</A> ::= constant_expression

<A NAME="constant_expression" HREF="#Rconstant_expression">constant_expression</A> ::=
 <A NAME="Rconstant_primary" HREF="#constant_primary">constant_primary</A>
 | <A NAME="Runary_operator" HREF="#unary_operator">unary_operator</A> { attribute_instance } constant_primary
 | constant_expression <A NAME="Rbinary_operator" HREF="#binary_operator">binary_operator</A> { attribute_instance } constant_expression
 | constant_expression ? { attribute_instance }
 constant_expression : constant_expression
 | <A NAME="Rstring" HREF="#string">string</A>

<A NAME="constant_mintypmax_expression" HREF="#Rconstant_mintypmax_expression">constant_mintypmax_expression</A> ::=
constant_expression
| constant_expression : constant_expression : constant_expression

<A NAME="constant_range_expression" HREF="#Rconstant_range_expression">constant_range_expression</A> ::=
 constant_expression
 | msb_constant_expression : lsb_constant_expression
 | constant_base_expression +: <A NAME="Rwidth_constant_expression" HREF="#width_constant_expression">width_constant_expression</A>
 | constant_base_expression -: width_constant_expression

<A NAME="dimension_constant_expression" HREF="#Rdimension_constant_expression">dimension_constant_expression</A> ::= constant_expression

<A NAME="expression1" HREF="#Rexpression1">expression1</A> ::= expression

<A NAME="expression2" HREF="#Rexpression2">expression2</A> ::= expression

<A NAME="expression3" HREF="#Rexpression3">expression3</A> ::= expression

<A NAME="expression" HREF="#Rexpression">expression</A> ::=
 <A NAME="Rprimary" HREF="#primary">primary</A>
 | unary_operator { attribute_instance } primary
 | expression binary_operator { attribute_instance } expression
 | conditional_expression
 | string

<A NAME="lsb_constant_expression" HREF="#Rlsb_constant_expression">lsb_constant_expression</A> ::= constant_expression

<A NAME="mintypmax_expression" HREF="#Rmintypmax_expression">mintypmax_expression</A> ::=
expression
| expression : expression : expression

<A NAME="module_path_conditional_expression" HREF="#Rmodule_path_conditional_expression">module_path_conditional_expression</A> ::=
module_path_expression ? { attribute_instance }
module_path_expression : module_path_expression

<A NAME="module_path_expression" HREF="#Rmodule_path_expression">module_path_expression</A> ::=
 <A NAME="Rmodule_path_primary" HREF="#module_path_primary">module_path_primary</A>
 | <A NAME="Runary_module_path_operator" HREF="#unary_module_path_operator">unary_module_path_operator</A> { attribute_instance } module_path_primary
 | module_path_expression <A NAME="Rbinary_module_path_operator" HREF="#binary_module_path_operator">binary_module_path_operator</A> { attribute_instance }
 module_path_expression
 | module_path_conditional_expression

<A NAME="module_path_mintypmax_expression" HREF="#Rmodule_path_mintypmax_expression">module_path_mintypmax_expression</A> ::=
module_path_expression
| module_path_expression : module_path_expression : module_path_expression

<A NAME="msb_constant_expression" HREF="#Rmsb_constant_expression">msb_constant_expression</A> ::= constant_expression

<A NAME="range_expression" HREF="#Rrange_expression">range_expression</A> ::=
 expression
 | msb_constant_expression : lsb_constant_expression
 | base_expression +: width_constant_expression
 | base_expression -: width_constant_expression

<A NAME="width_constant_expression" HREF="#Rwidth_constant_expression">width_constant_expression</A> ::= constant_expression

<H3>A.8.4 Primaries</H3>
<A NAME="constant_primary" HREF=&qu