hyperlinked BNF - 4/23

From: Adam Krolnik (adamk@cyrix.com)
Date: Thu Apr 23 1998 - 00:21:03 PDT

Next message: Clifford E. Cummings: "BE18 Hierarchical names"
Previous message: Cliff Cummings: "(no subject)"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ] [ attachment ]

Too Cool!

I haven't linked the definition to a usage. Would this be useful? Would the first one be okay?

I can color the unreferenced definitions. What color should I do?

Adam

Begin forwarded message:

Date: Thu, 23 Apr 1998 13:19:11 -0500
From: adamk
To: adamk
Subject: hyperlinked BNF

<TT>A.1 Source text </TT>

<TT><A NAME="source_text"></A>source_text ::= { description } </TT>

<TT><A NAME="description"></A>description ::= </TT>

<TT> module_declaration </TT>

<TT> | udp_declaration </TT>

<TT><A NAME="module_declaration"></A>module_declaration ::= </TT>

<TT> module_keyword module_identifier [ list_of_ports ] ; { module_item } endmodule </TT>

<TT><A NAME="module_keyword"></A>module_keyword ::= module | macromodule </TT>

<TT><A NAME="list_of_ports"></A>list_of_ports ::= ( port { , port } ) </TT>

<TT> [ port_expression ] </TT>

<TT> | . port_identifier ( [ port_expression ] ) </TT>

<TT><A NAME="port_expression"></A>port_expression ::= </TT>

<TT> port_reference </TT>

<TT> | { port_reference { , port_reference } } </TT>

<TT><A NAME="port_reference"></A>port_reference ::= </TT>

<TT> port_identifier </TT>

<TT> | port_identifier [ constant_expression ] </TT>

<TT> | port_identifier [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT>1995><A NAME="module_item"></A>module_item ::= </TT>

<TT>1995> module_item_declaration </TT>

<TT>1995> | parameter_override </TT>

<TT>1995> | continuous_assign </TT>

<TT>1995> | gate_instantiation </TT>

<TT>1995> | udp_instantiation </TT>

<TT>1995> | module_instantiation </TT>

<TT>1995> | specify_block </TT>

<TT>1995> | initial_construct </TT>

<TT>1995> | always_construct </TT>

<TT>1998 B01><A NAME="module_item"></A>module_item ::= </TT>

<TT>1998 B01> ungeneratable_module_item_declaration </TT>

<TT>1998 B01> | non_generated_module_item </TT>

<TT>1998 B01> | generated_instantiation </TT>

<TT>1998 B01> | specify_block </TT>

<TT>1998 B01><A NAME="ungeneratable_module_item_declaration"></A>ungeneratable_module_item_declaration ::= </TT>

<TT>1998 B01> parameter_declaration </TT>

<TT>1998 B01> | local_parameter_declaration </TT>

<TT>1998 B01> | input_declaration </TT>

<TT>1998 B01> | output_declaration </TT>

<TT>1998 B01> | inout_declaration </TT>

<TT>1998 B01><A NAME="non_generated_module_item"></A>non_generated_module_item ::= </TT>

<TT>1998 B01> generatable_module_item_declaration </TT>

<TT>1998 B01> | parameter_override </TT>

<TT>1998 B01> | continuous_assign </TT>

<TT>1998 B01> | gate_instantiation </TT>

<TT>1998 B01> | udp_instantiation </TT>

<TT>1998 B01> | module_instantiation </TT>

<TT>1998 B01> | initial_construct </TT>

<TT>1998 B01> | always_construct </TT>

<TT>1998 B01><A NAME="generatable_module_item_declaration"></A>generatable_module_item_declaration ::= </TT>

<TT>1998 B01> net_declaration </TT>

<TT>1998 B01> | reg_declaration </TT>

<TT>1998 B01> | integer_declaration </TT>

<TT>1998 B01> | real_declaration </TT>

<TT>1998 B01> | time_declaration </TT>

<TT>1998 B01> | realtime_declaration </TT>

<TT>1998 B01> | event_declaration </TT>

<TT>1998 B01> | task_declaration </TT>

<TT>1998 B01> | function_declaration </TT>

<TT><A NAME="module_item_declaration"></A>module_item_declaration ::= </TT>

<TT> parameter_declaration </TT>

<TT>1998 B??> | local_parameter_declaration </TT>

<TT> | input_declaration </TT>

<TT> | output_declaration </TT>

<TT> | inout_declaration </TT>

<TT> | net_declaration </TT>

<TT> | reg_declaration </TT>

<TT> | integer_declaration </TT>

<TT> | real_declaration </TT>

<TT> | time_declaration </TT>

<TT> | realtime_declaration </TT>

<TT> | event_declaration </TT>

<TT> | task_declaration </TT>

<TT> | function_declaration </TT>

<TT><A NAME="parameter_override"></A>parameter_override ::= defparam list_of_param_assignments ; </TT>

<TT>A.2 Declarations </TT>

<TT>1995><A NAME="parameter_declaration"></A>parameter_declaration ::= parameter list_of_param_assignments ; </TT>

<TT>1998 BE??><A NAME="parameter_declaration"></A>parameter_declaration ::= parameter [ range ] list_of_param_assignments ; </TT>

<TT><A NAME="list_of_param_assignments"></A>list_of_param_assignments ::= param_assignment { , param_assignment } </TT>

<TT>1998 B??><A NAME="local_parameter_declaration"></A>local_parameter_declaration ::= localparam list_of_local_param_assignments ; </TT>

<TT>1998 B??><A NAME="list_of_local_param_assignments"></A>list_of_local_param_assignments ::= param_assignment { , param_assignment } </TT>

<TT><A NAME="param_assignment"></A>param_assignment ::= parameter_identifier = constant_expression </TT>

<TT>1995><A NAME="input_declaration"></A>input_declaration ::= input [ range ] list_of_port_identifiers ; </TT>

<TT>1995><A NAME="output_declaration"></A>output_declaration ::= output [ range ] list_of_port_identifiers ; </TT>

<TT>1995><A NAME="inout_declaration"></A>inout_declaration ::= inout [ range ] list_of_port_identifiers ; </TT>

<TT>1998 B19/B09/B14><A NAME="input_declaration"></A>input_declaration ::= input [ signed ] [ net_type ] [ range ] list_of_port_identifiers ; </TT>

<TT>1998 B19/B09/B14><A NAME="output_declaration"></A>output_declaration ::= </TT>

<TT>1998 B19/B09/B14> output [ signed ] [ net_type ] [ range ] list_of_port_identifiers ; </TT>

<TT>1998 B19/B09/B14> | output [ signed ] [ reg_type ] [ range ] list_of_reg_port_identifiers ; </TT>

<TT>1998 B19/B09/B14><A NAME="inout_declaration"></A>inout_declaration ::= inout [ signed ] [ net_type ] [ range ] list_of_port_identifiers ; </TT>

<TT><A NAME="list_of_port_identifiers"></A>list_of_port_identifiers ::= port_identifier { , port_identifier } </TT>

<TT>1998 B14><A NAME="list_of_reg_port_identifiers"></A>list_of_reg_port_identifiers ::= port_identifier [ = constant_expression ] { , port_identifier [ = constant_expression ] } </TT>

<TT>1995><A NAME="reg_declaration"></A>reg_declaration ::= reg [ range ] list_of_register_identifiers ; </TT>

<TT>1995><A NAME="event_declaration"></A>event_declaration ::= event event_identifier { , event_identifier } ; </TT>

<TT>1995><A NAME="list_of_real_identifiers"></A>list_of_real_identifiers ::= real_identifier { , real_identifier } </TT>

<TT>1995><A NAME="list_of_register_identifiers"></A>list_of_register_identifiers ::= register_name { , register_name } </TT>

<TT>1995><A NAME="register_name"></A>register_name ::= </TT>

<TT>1995> register_identifier </TT>

<TT>1995> | memory_identifier [ upper_limit_constant_expression : lower_limit_constant_expression ] </TT>

<TT>1995><A NAME="range"></A>range ::= [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT>1995><A NAME="list_of_net_identifiers"></A>list_of_net_identifiers ::= net_identifier { , net_identifier } </TT>

<TT> (Question - were multi-dimensional tasks and functions also going to be permitted??? - </TT>

<TT> NO?! - breaks assignment rule) </TT>

<TT> (If this BNF is correct for multidimensional arrays, this will also be added to automatic tasks, etc.) </TT>

<TT>1998 B02/BE??><A NAME="reg_declaration"></A>reg_declaration ::= reg [ signed | unsigned ] [ range ] list_of_regmem_identifiers ; </TT>

<TT>1998 B02><A NAME="event_declaration"></A>event_declaration ::= event list_of_event_identifiers ; </TT>

<TT>1998 B02><A NAME="list_of_regmem_identifiers"></A>list_of_regmem_identifiers ::= register_name | memory_name { , register_name | memory_name } </TT>

<TT>1998 B02><A NAME="list_of_register_identifiers"></A>list_of_register_identifiers ::= register_name { , register_name } </TT>

<TT>1998 B02/BE??><A NAME="memory_name"></A>memory_name ::= memory_identifier [ upper_limit_constant_expression : lower_limit_constant_expression ] </TT>

<TT>1998 B02><A NAME="register_name"></A>register_name ::= register_identifier [ dimension { , dimension }] </TT>

<TT>1998 B02><A NAME="list_of_real_identifiers"></A>list_of_real_identifiers ::= real_identifier [ dimension { , dimension }] { , real_identifier [ dimension { , dimension }] } </TT>

<TT>1998 B02><A NAME="list_of_event_identifiers"></A>list_of_event_identifiers ::= event_identifier [ dimension { , dimension }] { , event_identifier [ dimension { , dimension }] } </TT>

<TT>1998 B02><A NAME="range"></A>range ::= [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT>1998 B02><A NAME="dimension"></A>dimension ::= [ dimension_constant_expression : dimension_constant_expression ] </TT>

<TT>1998 B02><A NAME="list_of_net_identifiers"></A>list_of_net_identifiers ::= net_identifier [ dimension { , dimension }] { , net_identifier [ dimension { , dimension }] } </TT>

<TT><A NAME="time_declaration"></A>time_declaration ::= time list_of_register_identifiers ; </TT>

<TT><A NAME="integer_declaration"></A>integer_declaration ::= integer list_of_register_identifiers ; </TT>

<TT><A NAME="real_declaration"></A>real_declaration ::= real list_of_real_identifiers ; </TT>

<TT><A NAME="realtime_declaration"></A>realtime_declaration ::= realtime list_of_real_identifiers ; </TT>

<TT>1995><A NAME="net_declaration"></A>net_declaration ::= </TT>

<TT>1995> net_type [ vectored | scalared ] [ range ] [ delay3 ] list_of_net_identifiers ; </TT>

<TT>1995> | trireg [ vectored | scalared ] [ charge_strength ] [ range ] [ delay3 ] </TT>

<TT>1995> list_of_net_identifiers ; </TT>

<TT>1995> | net_type [ vectored | scalared ] [ drive_strength ] [ range ] [ delay3 ] </TT>

<TT>1998 B19><A NAME="net_declaration"></A>net_declaration ::= </TT>

<TT>1998 B19> net_type [ vectored | scalared ] [ signed | unsigned ] [ range ] [ delay3 ] list_of_net_identifiers ; </TT>

<TT>1998 B19> | trireg [ vectored | scalared ] [ signed | unsigned ] [ charge_strength ] [ range ] [ delay3 ] </TT>

<TT>1998 B19> list_of_net_identifiers ; </TT>

<TT>1998 B19> | net_type [ vectored | scalared ] [ signed | unsigned ] [ drive_strength ] [ range ] [ delay3 ] </TT>

<TT> list_of_net_decl_assignments ; </TT>

<TT><A NAME="drive_strength"></A>drive_strength ::= </TT>

<TT> ( strength0 , strength1 ) </TT>

<TT> | ( strength1 , strength0 ) </TT>

<TT> | ( strength0 , highz1 ) </TT>

<TT> | ( strength1 , highz0 ) </TT>

<TT> | ( highz0 , strength1 ) </TT>

<TT> | ( highz1 , strength0 ) </TT>

<TT><A NAME="strength0"></A>strength0 ::= supply0 | strong0 | pull0 | weak0 </TT>

<TT><A NAME="strength1"></A>strength1 ::= supply1 | strong1 | pull1 | weak1 </TT>

<TT><A NAME="charge_strength"></A>charge_strength ::= ( small ) | ( medium ) | ( large ) </TT>

<TT><A NAME="delay3"></A>delay3 ::= # delay_value | # (delay_value [ , delay_value [ , delay_value ] ] ) </TT>

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

<TT><A NAME="delay_value"></A>delay_value ::= unsigned_number | parameter_identifier | constant_mintypmax_expression </TT>

<TT><A NAME="list_of_net_decl_assignments"></A>list_of_net_decl_assignments ::= net_decl_assignment { , net_decl_assignment } </TT>

<TT><A NAME="net_decl_assignment"></A>net_decl_assignment ::= net_identifier = expression </TT>

<TT><A NAME="function_declaration"></A>function_declaration ::= </TT>

<TT>1995> function [signed] [ range_or_type ] function_identifier ; </TT>

<TT>1998 B19> function [signed] [ range_or_type ] function_identifier ; </TT>

<TT> function_item_declaration { function_item_declaration } </TT>

<TT> statement </TT>

<TT> endfunction </TT>

<TT>1998 B??><A NAME="reg_type"></A>reg_type ::= reg | integer | real | realtime | time </TT>

<TT><A NAME="range_or_type"></A>range_or_type ::= range | integer | real | realtime | time </TT>

<TT><A NAME="function_item_declaration"></A>function_item_declaration ::= </TT>

<TT> block_item_declaration </TT>

<TT> | input_declaration </TT>

<TT>1998 B04><A NAME="recursive_function_declaration"></A>recursive_function_declaration ::= </TT>

<TT>1998 B04> function [ automatic ] [ range_or_type ] function_identifier ; </TT>

<TT>1998 B04> recursive_function_item_declaration { function_item_declaration } </TT>

<TT>1998 B04> statement </TT>

<TT>1998 B04> endfunction </TT>

<TT>1998 B04><A NAME="range_or_type"></A>range_or_type ::= range | integer | real | realtime | time </TT>

<TT>1998 B04><A NAME="recursive_function_item_declaration"></A>recursive_function_item_declaration ::= </TT>

<TT>1998 B04> automatic_block_item_declaration </TT>

<TT>1998 B04> | automatic_input_declaration </TT>

<TT><A NAME="task_declaration"></A>task_declaration ::= </TT>

<TT> task task_identifier ; </TT>

<TT> { task_item_declaration } </TT>

<TT>1995> statement_or_null </TT>

<TT>1998 BE??> statement </TT>

<TT> endtask </TT>

<TT>1998 B08><A NAME="combinational_task_declaration"></A>combinational_task_declaration ::= </TT>

<TT>1998 B08> task combinational_task_identifier ; </TT>

<TT>1998 B08> { task_item_declaration } </TT>

<TT>1998 B08> combinational_statement </TT>

<TT>1998 B08> endtask </TT>

<TT>1995>><A NAME="task_argument_declaration"></A>task_argument_declaration ::= </TT>

<TT>1998 BE43><A NAME="task_item_declaration"></A>task_item_declaration ::= </TT>

<TT> block_item_declaration </TT>

<TT>1998 BE43> | input_declaration </TT>

<TT> | output_declaration </TT>

<TT> | inout_declaration </TT>

<TT><A NAME="block_item_declaration"></A>block_item_declaration ::= </TT>

<TT> parameter_declaration </TT>

<TT>1998 B??> | local_parameter_declaration </TT>

<TT> | reg_declaration </TT>

<TT> | integer_declaration </TT>

<TT> | real_declaration </TT>

<TT> | time_declaration </TT>

<TT> | realtime_declaration </TT>

<TT> | event_declaration </TT>

<TT>1998 B04><A NAME="recursive_reentrant_task_declaration"></A>recursive_reentrant_task_declaration ::= </TT>

<TT>1998 B04> task [ automatic ] task_identifier ; </TT>

<TT>1998 B04> { recursive_reentrant_task_item_declaration } </TT>

<TT>1998 B04> statement </TT>

<TT>1998 B04> endtask </TT>

<TT>1998 B04><A NAME="recursive_reentrant_task_item_declaration"></A>recursive_reentrant_task_item_declaration ::= </TT>

<TT>1998 B04> automatic_block_item_declaration </TT>

<TT>1998 B04> | automatic_input_declaration </TT>

<TT>1998 B04> | automatic_output_declaration </TT>

<TT>1998 B04> | automatic_inout_declaration </TT>

<TT>1998 B04><A NAME="automatic_block_item_declaration"></A>automatic_block_item_declaration ::= </TT>

<TT>1998 B04> parameter_declaration </TT>

<TT>1998 B04> | local_parameter_declaration </TT>

<TT>1998 B04> | automatic_reg_declaration </TT>

<TT>1998 B04> | automatic_integer_declaration </TT>

<TT>1998 B04> | automatic_time_declaration </TT>

<TT>1998 B04> | automatic_real_declaration </TT>

<TT>1998 B04> | automatic_realtime_declaration </TT>

<TT>1998 B04> | automatic_event_declaration </TT>

<TT>1998 B04/B19><A NAME="automatic_input_declaration"></A>automatic_input_declaration ::= input [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT>1998 B04/B19><A NAME="automatic_output_declaration"></A>automatic_output_declaration ::= output [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT>1998 B04/B19><A NAME="automatic_inout_declaration"></A>automatic_inout_declaration ::= inout [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT>1998 B04/B19><A NAME="automatic_reg_declaration"></A>automatic_reg_declaration ::= reg [ automatic ] [ signed | unsigned ] [range] list_of_regmem_identifiers ; </TT>

<TT>1998 B04><A NAME="automatic_integer_declaration"></A>automatic_integer_declaration ::= integer [ automatic ] list_of_register_identifiers ; </TT>

<TT>1998 B04><A NAME="automatic_time_declaration"></A>automatic_time_declaration ::= time [ automatic ] list_of_register_identifiers ; </TT>

<TT>1998 B04><A NAME="automatic_real_declaration"></A>automatic_real_declaration ::= real [ automatic ] list_of_real_identifiers ; </TT>

<TT>1998 B04><A NAME="automatic_realtime_declaration"></A>automatic_realtime_declaration ::= realtime [ automatic ] list_of_real_identifiers ; </TT>

<TT>1998 B04><A NAME="automatic_event_declaration"></A>automatic_event_declaration ::= event [ automatic ] list_of_event_identifiers ; </TT>

<TT>A.3 Primitive instances </TT>

<TT><A NAME="gate_instantiation"></A>gate_instantiation ::= </TT>

<TT> n_input_gatetype [drive_strength] [delay2] n_input_gate_instance { , n_input_gate_instance } ; </TT>

<TT> | n_output_gatetype [drive_strength] [delay2] n_output_gate_instance { , n_output_gate_instance } ; </TT>

<TT> | enable_gatetype [drive_strength] [delay3] enable_gate_instance { , enable_gate_instance } ; </TT>

<TT> | mos_switchtype [delay3] mos_switch_instance { , mos_switch_instance } ; </TT>

<TT> | pass_switchtype pass_switch_instance { , pass_switch_instance } ; </TT>

<TT>1995> | pass_en_switchtype [delay3] pass_en_switch_instance { , pass_en_switch_instance } ; </TT>

<TT>1998 BE??> | pass_en_switchtype [delay2] pass_enable_switch_instance { , pass_enable_switch_instance } ; </TT>

<TT> | cmos_switchtype [delay3] cmos_switch_instance { , cmos_switch_instance } ; </TT>

<TT> | pullup [pullup_strength] pull_gate_instance { , pull_gate_instance } ; </TT>

<TT> | pulldown [pulldown_strength] pull_gate_instance { , pull_gate_instance } ; </TT>

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

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

<TT><A NAME="enable_gate_instance"></A>enable_gate_instance ::= [name_of_gate_instance] ( output_terminal , input_terminal , enable_terminal ) </TT>

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

<TT><A NAME="pass_switch_instance"></A>pass_switch_instance ::= [name_of_gate_instance] ( inout_terminal , inout_terminal ) </TT>

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

<TT><A NAME="cmos_switch_instance"></A>cmos_switch_instance ::= [name_of_gate_instance] ( output_terminal , input_terminal , </TT>

<TT> ncontrol_terminal , pcontrol_terminal) </TT>

<TT><A NAME="pull_gate_instance"></A>pull_gate_instance ::= [name_of_gate_instance] (output_terminal ) </TT>

<TT><A NAME="name_of_gate_instance"></A>name_of_gate_instance ::= gate_instance_identifier [range] </TT>

<TT><A NAME="pullup_strength"></A>pullup_strength ::= </TT>

<TT> ( strength0 , strength1 ) </TT>

<TT> | ( strength1 , strength0 ) </TT>

<TT> | ( strength1 ) </TT>

<TT><A NAME="pulldown_strength"></A>pulldown_strength ::= </TT>

<TT> ( strength0 , strength1 ) </TT>

<TT> | ( strength1 , strength0 ) </TT>

<TT> | ( strength0 ) </TT>

<TT><A NAME="input_terminal"></A>input_terminal ::= scalar_expression </TT>

<TT><A NAME="enable_terminal"></A>enable_terminal ::= scalar_expression </TT>

<TT><A NAME="ncontrol_terminal"></A>ncontrol_terminal ::= scalar_expression </TT>

<TT><A NAME="pcontrol_terminal"></A>pcontrol_terminal ::= scalar_expression </TT>

<TT><A NAME="output_terminal"></A>output_terminal ::= terminal_identifier | terminal_identifier [ constant_expression ] </TT>

<TT><A NAME="inout_terminal"></A>inout_terminal ::= terminal_identifier | terminal_identifier [ constant_expression ] </TT>

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

<TT><A NAME="n_output_gatetype"></A>n_output_gatetype ::= buf | not </TT>

<TT><A NAME="enable_gatetype"></A>enable_gatetype ::= bufif0 | bufif1 | notif0 | notif1 </TT>

<TT><A NAME="mos_switchtype"></A>mos_switchtype ::= nmos | pmos | rnmos | rpmos </TT>

<TT><A NAME="pass_switchtype"></A>pass_switchtype ::= tran | rtran </TT>

<TT><A NAME="pass_en_switchtype"></A>pass_en_switchtype ::= tranif0 | tranif1 | rtranif1 | rtranif0 </TT>

<TT><A NAME="cmos_switchtype"></A>cmos_switchtype ::= cmos | rcmos </TT>

<TT>1995>A.4 Module instantiation </TT>

<TT>1998 B01>A.4 Module and generated instantiation </TT>

<TT><A NAME="module_instantiation"></A>module_instantiation ::= </TT>

<TT> module_identifier [ parameter_value_assignment ] module_instance { , module_instance } ; </TT>

<TT>1995><A NAME="parameter_value_assignment"></A>parameter_value_assignment ::= # ( expression { , expression } ) </TT>

<TT>1998 B06><A NAME="parameter_value_assignment"></A>parameter_value_assignment ::= # ( list_of_parameter_assignments ) </TT>

<TT>1998 B06><A NAME="list_of_parameter_assignments"></A>list_of_parameter_assignments ::= </TT>

<TT>1998 B06> ordered_parameter_assignment { , ordered_parameter_assignment } | </TT>

<TT>1998 B06> named_parameter_assignment { , named_parameter_assignment } </TT>

<TT>1998 B06><A NAME="ordered_parameter_assignment"></A>ordered_parameter_assignment ::= expression </TT>

<TT>1998 B06><A NAME="named_parameter_assignment"></A>named_parameter_assignment ::= . parameter_identifier ( [expression] ) </TT>

<TT><A NAME="module_instance"></A>module_instance ::= name_of_instance ( [list_of_module_connections] ) </TT>

<TT><A NAME="name_of_instance"></A>name_of_instance ::= module_instance_identifier [ range ] </TT>

<TT><A NAME="list_of_module_connections"></A>list_of_module_connections ::= </TT>

<TT> ordered_port_connection { , ordered_port_connection } </TT>

<TT> | named_port_connection { , named_port_connection } </TT>

<TT><A NAME="ordered_port_connection"></A>ordered_port_connection ::= [ expression ] </TT>

<TT><A NAME="named_port_connection"></A>named_port_connection ::= .port_identifier ( [ expression ] ) </TT>

<TT>1998 B01><A NAME="genvar_declaration"></A>genvar_declaration ::= genvar list_of_genvar_identifiers ; </TT>

<TT>1998 B01><A NAME="list_of_genvar_identifiers"></A>list_of_genvar_identifiers ::= </TT>

<TT>1998 B01> genvar_identifier { , genvar_identifier } </TT>

<TT>1998 B01><A NAME="generated_instantiation"></A>generated_instantiation ::= generate { generate_item } endgenerate </TT>

<TT>1998 B01><A NAME="generate_item_or_null"></A>generate_item_or_null ::= generate_item | ; </TT>

<TT>1998 B01><A NAME="generate_item"></A>generate_item ::= </TT>

<TT>1998 B01> generate_conditional_statement </TT>

<TT>1998 B01> | generate_case_statement </TT>

<TT>1998 B01> | generate_loop_statement </TT>

<TT>1998 B01> | generate_block </TT>

<TT>1998 B01> | non_generated_module_item </TT>

<TT>1998 B01><A NAME="generate_conditional_statement"></A>generate_conditional_statement ::= </TT>

<TT>1998 B01> if ( genvar_expression ) generate_item_or_null [ else generate_item_or_null ] </TT>

<TT>1998 B01><A NAME="generate_case_statement"></A>generate_case_statement ::= case ( genvar_expression ) </TT>

<TT>1998 B01>genvar_case_item { genvar_case_item } endcase </TT>

<TT>1998 B01><A NAME="genvar_case_item"></A>genvar_case_item ::= genvar_expression { , genvar_expression } : </TT>

<TT>1998 B01> generate_item_or_null | default [ : ] generate_item_or_null </TT>

<TT>1998 B01><A NAME="generate_loop_statement"></A>generate_loop_statement ::= for ( genvar_assignment ; genvar_expression ; genvar_assignment ) generate_item </TT>

<TT>1998 B01><A NAME="genvar_assignment"></A>genvar_assignment ::= genvar_identifier = genvar_expression </TT>

<TT>1998 B01><A NAME="generate_block"></A>generate_block ::= begin [ : generate_block_identifier ] { generate_item } end </TT>

<TT>A.5 UDP declaration and instantiation </TT>

<TT><A NAME="udp_declaration"></A>udp_declaration ::= </TT>

<TT>1995> primitive udp_identifier ( udp_port_list ) ; </TT>

<TT>1998 B??> primitive udp_identifier [ ( udp_port_list ) ] ; </TT>

<TT> udp_port_declaration { udp_port_declaration } </TT>

<TT> endprimitive </TT>

<TT><A NAME="udp_port_list"></A>udp_port_list ::= output_port_identifier , input_port_identifier { , input_port_identifier } </TT>

<TT><A NAME="udp_port_declaration"></A>udp_port_declaration ::= </TT>

<TT>1995> output_declaration </TT>

<TT>1995> | input_declaration </TT>

<TT>1995> | reg_declaration </TT>

<TT>1998 BE??> udp_output_declaration </TT>

<TT>1998 BE??> | udp_input_declaration </TT>

<TT>1998 BE??> | udp_reg_declaration </TT>

<TT>1998 BE??><A NAME="udp_output_declaration"></A>udp_output_declaration ::= </TT>

<TT>1998 BE??> output port_identifier ; </TT>

<TT>1998 BE??> | output reg port_identifier [ = constant_expression ] ; </TT>

<TT>1998 BE??><A NAME="udp_input_declaration"></A>udp_input_declaration ::= </TT>

<TT>1998 BE??> input list_of_port_identifiers ; </TT>

<TT>1998 BE??><A NAME="udp_reg_declaration"></A>udp_reg_declaration ::= reg register_identifier ; </TT>

<TT><A NAME="udp_body"></A>udp_body ::= combinational_body | sequential_body </TT>

<TT><A NAME="combinational_body"></A>combinational_body ::= table combinational_entry { combinational_entry } endtable </TT>

<TT><A NAME="combinational_entry"></A>combinational_entry ::= level_input_list : output_symbol ; </TT>

<TT><A NAME="sequential_body"></A>sequential_body ::= [ udp_initial statement ] table sequential_entry { sequential_entry } endtable </TT>

<TT>udp_initial <A NAME="statement"></A>statement ::= initial udp_output_port_identifier = init_val ; </TT>

<TT><A NAME="sequential_entry"></A>sequential_entry ::= seq_input_list : current_state : next state ; </TT>

<TT><A NAME="seq_input_list"></A>seq_input_list ::= level_input_list | edge_input_list </TT>

<TT><A NAME="level_input_list"></A>level_input_list ::= level_symbol { level_symbol } </TT>

<TT><A NAME="edge_input_list"></A>edge_input_list ::= { level_symbol } edge_indicator { level_symbol } </TT>

<TT><A NAME="edge_indicator"></A>edge_indicator ::= ( level_symbol level_symbol ) | edge_symbol </TT>

<TT><A NAME="current_state"></A>current_state ::= level_symbol </TT>

<TT>next <A NAME="state"></A>state ::= output_symbol | - </TT>

<TT><A NAME="output_symbol"></A>output_symbol ::= 0 | 1 | x | X </TT>

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

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

<TT><A NAME="udp_instantiation"></A>udp_instantiation ::= udp_identifier [ drive_strength ] [ delay2 ] udp_instance { , udp_instance } ; </TT>

<TT><A NAME="udp_instance"></A>udp_instance ::= [ name_of_udp_instance ] ( output_port_connection , input_port_connection </TT>

<TT> { , input_port_connection } ) </TT>

<TT><A NAME="name_of_udp_instance"></A>name_of_udp_instance ::= udp_instance_identifier [ range ] </TT>

<TT>A.6 Behavioral statements </TT>

<TT><A NAME="continuous_assign"></A>continuous_assign ::= assign [drive_strength] [delay3] list_of_net_assignments ; </TT>

<TT><A NAME="list_of_net_assignments"></A>list_of_net_assignments ::= net_assignment { , net_assignment } </TT>

<TT><A NAME="net_assignment"></A>net_assignment ::= net_lvalue = expression </TT>

<TT><A NAME="initial_construct"></A>initial_construct ::= initial statement </TT>

<TT><A NAME="always_construct"></A>always_construct ::= always statement </TT>

<TT>1998 B08><A NAME="always_combinational_construct"></A>always_combinational_construct ::= always @* combinational_statement </TT>

<TT><A NAME="statement"></A>statement ::= </TT>

<TT> blocking_assignment ; </TT>

<TT>1995> | non_blocking assignment ; </TT>

<TT>1998 BE41> | non_blocking_assignment ; </TT>

<TT> | procedural_continuous_assignments ; </TT>

<TT> | procedural_timing_control_statement </TT>

<TT> | conditional_statement </TT>

<TT> | case_statement </TT>

<TT> | loop_statement </TT>

<TT> | wait_statement </TT>

<TT> | disable_statement </TT>

<TT> | event_trigger </TT>

<TT> | seq_block </TT>

<TT> | par_block </TT>

<TT> | task_enable </TT>

<TT> | system_task_enable </TT>

<TT><A NAME="statement_or_null"></A>statement_or_null ::= statement | ; </TT>

<TT>1995>blocking <A NAME="assignment"></A>assignment ::= reg_lvalue = [ delay_or_event_control ] expression </TT>

<TT>1995>non-blocking <A NAME="assignment"></A>assignment ::= reg_lvalue <= [ delay_or_event_control ] expression </TT>

<TT>1998 BE41><A NAME="blocking_assignment"></A>blocking_assignment ::= reg_lvalue = [ delay_or_event_control ] expression </TT>

<TT>1998 BE41><A NAME="non_blocking_assignment"></A>non_blocking_assignment ::= reg_lvalue <= [ delay_or_event_control ] expression </TT>

<TT><A NAME="procedural_continuous_assignments"></A>procedural_continuous_assignments ::= </TT>

<TT>1995> | assign reg_assignment ; </TT>

<TT>1998 BE41> assign reg_assignment ; </TT>

<TT> | deassign reg_assignment ; </TT>

<TT> | force reg_assignment ; </TT>

<TT> | force net_assignment ; </TT>

<TT> | release reg_lvalue ; </TT>

<TT> | release net_lvalue ; </TT>

<TT><A NAME="procedural_timing_control_statement"></A>procedural_timing_control_statement ::= </TT>

<TT> delay_or_event_control statement_or_null </TT>

<TT>1998 B08><A NAME="combinational_statement"></A>combinational_statement ::= </TT>

<TT>1998 B08> combinational_blocking_assignment ; </TT>

<TT>1998 B08> | combinational_non_blocking_assignment ; </TT>

<TT>1998 B08> | combinational_procedural_timing_control_statement </TT>

<TT>1998 B08> | combinational_conditional_statement </TT>

<TT>1998 B08> | combinational_case_statement </TT>

<TT>1998 B08> | combinational_loop_statement </TT>

<TT>1998 B08> | disable_statement </TT>

<TT>1998 B08> | combinational_seq_block </TT>

<TT>1998 B08> | combinational_task_enable </TT>

<TT>1998 B08> | system_task_enable </TT>

<TT>1998 B08><A NAME="combinational_blocking_assignment"></A>combinational_blocking_assignment ::= reg_lvalue = [ delay_control ] expression </TT>

<TT>1998 B08><A NAME="combinational_non_blocking_assignment"></A>combinational_non_blocking_assignment ::= reg_lvalue <= [ delay_control ] expression </TT>

<TT>1998 B08><A NAME="combinational_procedural_timing_control_statement"></A>combinational_procedural_timing_control_statement ::= </TT>

<TT>1998 B08> delay_control combinational_statement_or_null </TT>

<TT>1998 BE??><A NAME="function_statement"></A>function_statement ::= </TT>

<TT>1998 BE??> function_blocking_assignment ; </TT>

<TT>1998 BE??> | function_non_blocking_assignment ; </TT>

<TT>1998 BE??> | function_conditional_statement </TT>

<TT>1998 BE??> | function_case_statement </TT>

<TT>1998 BE??> | function_loop_statement </TT>

<TT>1998 BE??> | disable_statement </TT>

<TT>1998 BE??> | combinational_seq_block </TT>

<TT>1998 BE??> | system_task_enable </TT>

<TT>1998 BE??><A NAME="function_blocking_assignment"></A>function_blocking_assignment ::= reg_lvalue = expression </TT>

<TT>1998 BE??><A NAME="function_non_blocking_assignment"></A>function_non_blocking_assignment ::= reg_lvalue <= [ delay_control ] expression </TT>

<TT>1998 BE??><A NAME="function_statement_or_null"></A>function_statement_or_null ::= function_statement | ; </TT>

<TT><A NAME="delay_or_event_control"></A>delay_or_event_control ::= </TT>

<TT> delay_control </TT>

<TT> | event_control </TT>

<TT> | repeat ( expression ) event_control </TT>

<TT><A NAME="delay_control"></A>delay_control ::= </TT>

<TT> # delay_value </TT>

<TT> | # ( mintypmax_expression ) </TT>

<TT><A NAME="event_control"></A>event_control ::= </TT>

<TT> @ event_identifier </TT>

<TT> | @ ( event_expression ) </TT>

<TT><A NAME="event_expression"></A>event_expression ::= </TT>

<TT> expression </TT>

<TT> | event_identifier </TT>

<TT> | posedge expression </TT>

<TT> | negedge expression </TT>

<TT> | event_expression or event_expression </TT>

<TT>1998 B07> | event_expression , event_expression </TT>

<TT><A NAME="conditional_statement"></A>conditional_statement ::= </TT>

<TT>1995> | if ( expression ) statement_or_null [ else statement_or_null ] </TT>

<TT>1998 BE41> if ( expression ) statement_or_null [ else statement_or_null ] </TT>

<TT><A NAME="case_statement"></A>case_statement ::= </TT>

<TT>1995> | case ( expression ) case_item [ case_item ] endcase </TT>

<TT>1998 BE41> case ( expression ) case_item [ case_item ] endcase </TT>

<TT> | casez ( expression ) case_item [ case_item ] endcase </TT>

<TT> | casex ( expression ) case_item [ case_item ] endcase </TT>

<TT> expression { , expression } : statement_or_null </TT>

<TT> | default [ : ] statement_or_null </TT>

<TT><A NAME="loop_statement"></A>loop_statement ::= </TT>

<TT>1995> | forever statement </TT>

<TT>1998 BE10> forever statement </TT>

<TT> | repeat ( expression ) statement </TT>

<TT> | while ( expression ) statement </TT>

<TT> | for ( reg_assignment ; expression ; reg_assignment ) statement </TT>

<TT>1998 B08><A NAME="combinational_conditional_statement"></A>combinational_conditional_statement ::= </TT>

<TT>1998 B08> if ( expression ) combinational_statement_or_null [ else combinational_statement_or_null ] </TT>

<TT>1998 B08><A NAME="combinational_case_statement"></A>combinational_case_statement ::= </TT>

<TT>1998 B08> case ( expression ) case_item [ combinational_case_item ] endcase </TT>

<TT>1998 B08> | casez ( expression ) case_item [ combinational_case_item ] endcase </TT>

<TT>1998 B08> | casex ( expression ) case_item [ combinational_case_item ] endcase </TT>

<TT>1998 B08><A NAME="combinational_case_item"></A>combinational_case_item ::= </TT>

<TT>1998 B08> expression { , expression } : combinational_statement_or_null </TT>

<TT>1998 B08> | default [ : ] combinational_statement_or_null </TT>

<TT>1998 B08><A NAME="combinational_loop_statement"></A>combinational_loop_statement ::= </TT>

<TT>1998 B08> forever combinational_statement </TT>

<TT>1998 B08> | repeat ( expression ) combinational_statement </TT>

<TT>1998 B08> | while ( expression ) combinational_statement </TT>

<TT>1998 B08> | for ( reg_assignment ; expression ; reg_assignment ) combinational_statement </TT>

<TT>1998 B08><A NAME="combinational_seq_block"></A>combinational_seq_block ::= begin [ : block_identifier { block_item_declaration } ] { combinational_statement } end </TT>

<TT>1998 B08><A NAME="combinational_task_enable"></A>combinational_task_enable ::= combinational_task_identifier [ ( expression { , expression } ) ] ; </TT>

<TT>1998 BE??><A NAME="function_conditional_statement"></A>function_conditional_statement ::= </TT>

<TT>1998 BE??> if ( expression ) function_statement_or_null [ else function_statement_or_null ] </TT>

<TT>1998 BE??><A NAME="function_case_statement"></A>function_case_statement ::= </TT>

<TT>1998 BE??> case ( expression ) case_item [ function_case_item ] endcase </TT>

<TT>1998 BE??> | casez ( expression ) case_item [ function_case_item ] endcase </TT>

<TT>1998 BE??> | casex ( expression ) case_item [ function_case_item ] endcase </TT>

<TT>1998 BE??><A NAME="function_case_item"></A>function_case_item ::= </TT>

<TT>1998 BE??> expression { , expression } : function_statement_or_null </TT>

<TT>1998 BE??> | default [ : ] function_statement_or_null </TT>

<TT>1998 BE??><A NAME="function_loop_statement"></A>function_loop_statement ::= </TT>

<TT>1998 BE??> forever function_statement </TT>

<TT>1998 BE??> | repeat ( expression ) function_statement </TT>

<TT>1998 BE??> | while ( expression ) function_statement </TT>

<TT>1998 BE??> | for ( reg_assignment ; expression ; reg_assignment ) function_statement </TT>

<TT>1998 BE??><A NAME="function_seq_block"></A>function_seq_block ::= begin [ : block_identifier { block_item_declaration } ] { function_statement } end </TT>

<TT><A NAME="reg_assignment"></A>reg_assignment ::= reg_lvalue = expression </TT>

<TT><A NAME="wait_statement"></A>wait_statement ::= </TT>

<TT>1995> | wait ( expression ) statement_or_null </TT>

<TT>1998 BE41> wait ( expression ) statement_or_null </TT>

<TT><A NAME="event_trigger"></A>event_trigger ::= </TT>

<TT>1995> | -> event_identifier ; </TT>

<TT>1998 BE41> -> event_identifier ; </TT>

<TT><A NAME="disable_statement"></A>disable_statement ::= </TT>

<TT>1995> | disable task_identifier ; </TT>

<TT>1998 BE41> disable task_identifier ; </TT>

<TT> | disable block_identifier ; </TT>

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

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

<TT><A NAME="task_enable"></A>task_enable ::= task_identifier [ ( expression { , expression } ) ] ; </TT>

<TT>1995><A NAME="system_task_enable"></A>system_task_enable ::= system_task_name [ ( expression { , expression } ) ] ; </TT>

<TT>1995><A NAME="system_task_name"></A>system_task_name ::= $identifier Note: The $ may not be followed by a space. </TT>

<TT>1998 BE49><A NAME="system_task_enable"></A>system_task_enable ::= system_task_function_name [ ( expression { , expression } ) ] ; </TT>

<TT>A.7 Specify section </TT>

<TT><A NAME="specify_block"></A>specify_block ::= specify { specify_item } endspecify ; </TT>

<TT><A NAME="specify_item"></A>specify_item ::= </TT>

<TT> specparam_declaration </TT>

<TT> | path_declaration </TT>

<TT> | system_timing_check </TT>

<TT><A NAME="specparam_declaration"></A>specparam_declaration ::= specparam list_of_specparam_assignments ; </TT>

<TT><A NAME="list_of_specparam_assignments"></A>list_of_specparam_assignments ::= specparam_assignment { , specparam_assignment } </TT>

<TT><A NAME="specparam_assignment"></A>specparam_assignment ::= </TT>

<TT>1995> specparam_identifier = constant_expression </TT>

<TT>1998 BE29> specparam_identifier = constant_mintypmax_expression </TT>

<TT> | pulse_control_specparam </TT>

<TT><A NAME="pulse_control_specparam"></A>pulse_control_specparam ::= </TT>

<TT> PATHPULSE$ = ( reject_limit_value [ , error_limit_value ] ) ; </TT>

<TT> | PATHPULSE$specify_input_terminal_descriptor$specify_output_terminal_descriptor </TT>

<TT> = ( reject_limit_value [ , error_limit_value ] ) ; </TT>

<TT><A NAME="limit_value"></A>limit_value ::= constant_mintypmax_expression </TT>

<TT><A NAME="path_declaration"></A>path_declaration ::= </TT>

<TT> simple_path_declaration ; </TT>

<TT> | edge_sensitive_path_declaration ; </TT>

<TT>1995> | state-dependent_path_declaration ; </TT>

<TT>1998 BE41> | state_dependent_path_declaration ; </TT>

<TT><A NAME="simple_path_declaration"></A>simple_path_declaration ::= </TT>

<TT> parallel_path_description = path_delay_value </TT>

<TT> | full_path_description = path_delay_value </TT>

<TT><A NAME="parallel_path_description"></A>parallel_path_description ::= </TT>

<TT> ( specify_input_terminal_descriptor [ polarity_operator ] => specify_output_terminal_descriptor ) </TT>

<TT>full_path_description </TT>

<TT> ( list_of_path_inputs [ polarity_operator ] *> list_of_path_outputs ) </TT>

<TT><A NAME="list_of_path_inputs"></A>list_of_path_inputs ::= </TT>

<TT> ( specify_input_terminal_descriptor { , specify_input_terminal_descriptor } </TT>

<TT><A NAME="list_of_path_outputs"></A>list_of_path_outputs ::= </TT>

<TT> ( specify_output_terminal_descriptor { , specify_output_terminal_descriptor } </TT>

<TT><A NAME="specify_input_terminal_descriptor"></A>specify_input_terminal_descriptor ::= </TT>

<TT> input_identifier </TT>

<TT> | input_identifier [ constant_expression ] </TT>

<TT> | input_identifier [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT><A NAME="specify_output_terminal_descriptor"></A>specify_output_terminal_descriptor ::= </TT>

<TT> output_identifier </TT>

<TT> | output_identifier [ constant_expression ] </TT>

<TT> | output_identifier [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT><A NAME="input_identifier"></A>input_identifier ::= input_port_identifier | inout_port_identifier </TT>

<TT><A NAME="output_identifier"></A>output_identifier ::= output_port_identifier | inout_port_identifier </TT>

<TT><A NAME="polarity_operator"></A>polarity_operator ::= + | - </TT>

<TT><A NAME="path_delay_value"></A>path_delay_value ::= </TT>

<TT> list_of_path_delay_expressions </TT>

<TT> | ( list_of_path_delay_expressions ) </TT>

<TT><A NAME="list_of_path_delay_expressions"></A>list_of_path_delay_expressions ::= </TT>

<TT> t_path_delay_expression </TT>

<TT> | trise_path_delay_expression , tfall_path_delay_expression </TT>

<TT> | trise_path_delay_expression , tfall_path_delay_expression , tz_path_delay_expression </TT>

<TT> | t01_path_delay_expression , t10_path_delay_expression , t0z_path_delay_expression , </TT>

<TT> tz1_path_delay_expression , t1z_path_delay_expression , tz0_path_delay_expression </TT>

<TT> | t01_path_delay_expression , t10_path_delay_expression , t0z_path_delay_expression , </TT>

<TT> tz1_path_delay_expression , t1z_path_delay_expression , tz0_path_delay_expression </TT>

<TT> t0x_path_delay_expression , tx1_path_delay_expression , t1x_path_delay_expression , </TT>

<TT> tx0_path_delay_expression , txz_path_delay_expression , tzx_path_delay_expression </TT>

<TT><A NAME="path_delay_expression"></A>path_delay_expression ::= constant_mintypmax_expression </TT>

<TT><A NAME="edge_sensitive_path_declaration"></A>edge_sensitive_path_declaration ::= </TT>

<TT> parallel_edge_sensitive_path_description = path_delay_value </TT>

<TT> | full_edge_sensitive_path_description = path_delay_value </TT>

<TT><A NAME="parallel_edge_sensitive_path_description"></A>parallel_edge_sensitive_path_description ::= </TT>

<TT> ( [ edge_identifier ] specify_input_terminal_descriptor => </TT>

<TT>1995> specify_output_terminal_descriptor [ polarity_operator ] : data_source_expression ) ) </TT>

<TT>1998 BE??> specify_output_terminal_descriptor [ polarity_operator ] : data_source_expression ) </TT>

<TT><A NAME="full_edge_sensitive_path_description"></A>full_edge_sensitive_path_description ::= </TT>

<TT> ( [ edge_identifier ] list_of_path_inputs *> </TT>

<TT>1995> list_of_path_inputs [ polarity_operator ] : data_source_expression ) ) </TT>

<TT>1998 BE??> list_of_path_inputs [ polarity_operator ] : data_source_expression ) </TT>

<TT><A NAME="data_source_expression"></A>data_source_expression ::= expression </TT>

<TT><A NAME="edge_identifier"></A>edge_identifier ::= posedge | negedge </TT>

<TT><A NAME="state_dependent_path_declaration"></A>state_dependent_path_declaration ::= </TT>

<TT> if ( conditional_expression ) simple_path_declaration </TT>

<TT> | if ( conditional_expression ) edge_sensitive_path_declaration </TT>

<TT> | ifnone simple_path_declaration </TT>

<TT><A NAME="system_timing_check"></A>system_timing_check ::= </TT>

<TT> $setup ( timing_check_event , timing_check_event , timing_check_limit [ , notify_register ] ) ; </TT>

<TT> | $hold ( timing_check_event , timing_check_event , timing_check_limit [ , notify_register ] ) ; </TT>

<TT> | $period ( controlled_timing_check_event , timing_check_limit [ , notify_register ] ) ; </TT>

<TT> | $width ( controlled_timing_check_event , timing_check_limit , </TT>

<TT> constant_expression [ , notify_register ] ) ; </TT>

<TT> | $skew ( timing_check_event , timing_check_event , timing_check_limit [ , notify_register ] ) ; </TT>

<TT> | $recovery ( controlled_timing_check_event , timing_check_event , </TT>

<TT> timing_check_limit [ , notify_register ] ) ; </TT>

<TT> | $setuphold ( timing_check_event , timing_check_event , timing_check_limit , </TT>

<TT> timing_check_limit [ , notify_register ] ) ; </TT>

<TT>1998 BE02> | $nochange ( reference_event , data_event , start_edge_offset , </TT>

<TT>1998 BE02> end_edge_offset [ , notify_register ] ) ; </TT>

<TT><A NAME="timing_check_event"></A>timing_check_event ::= </TT>

<TT> [timing_check_event_control] specify_terminal_descriptor [ &&& timing_check_condition ] </TT>

<TT><A NAME="specify_terminal_descriptor"></A>specify_terminal_descriptor ::= </TT>

<TT> specify_input_terminal_descriptor </TT>

<TT> | specify_output_terminal_descriptor </TT>

<TT><A NAME="controlled_timing_check_event"></A>controlled_timing_check_event ::= </TT>

<TT> timing_check_event_control specify_terminal_descriptor [ &&& timing_check_condition ] </TT>

<TT><A NAME="timing_check_event_control"></A>timing_check_event_control ::= </TT>

<TT> posedge </TT>

<TT> | negedge </TT>

<TT> | edge_control_specifier </TT>

<TT><A NAME="edge_control_specifier"></A>edge_control_specifier ::= edge [ edge_descriptor [ , edge_descriptor ] ] </TT>

<TT>1995><A NAME="edge_descriptor"></A>edge_descriptor ::= </TT>

<TT>1998 BE27><A NAME="edge_descriptor1"></A>edge_descriptor1 ::= </TT>

<TT><A NAME="timing_check_condition"></A>timing_check_condition ::= </TT>

<TT> scalar_timing_check_condition </TT>

<TT> | ( scalar_timing_check_condition ) </TT>

<TT><A NAME="scalar_timing_check_condition"></A>scalar_timing_check_condition ::= </TT>

<TT> expression </TT>

<TT> | ~ expression </TT>

<TT> | expression == scalar_constant </TT>

<TT> | expression === scalar_constant </TT>

<TT> | expression != scalar_constant </TT>

<TT>1998 BE07> | expression !== scalar_constant </TT>

<TT><A NAME="timing_check_limit"></A>timing_check_limit ::= expression </TT>

<TT><A NAME="scalar_constant"></A>scalar_constant ::= </TT>

<TT><A NAME="notify_register"></A>notify_register ::= register_identifier </TT>

<TT>1998 BE27>NOTES </TT>

<TT>1998 BE27>1- Embedded spaces are illegal </TT>

<TT>A.8 Expressions </TT>

<TT>1998 B01><A NAME="genvar_expression"></A>genvar_expression ::= </TT>

<TT>1998 B01> genvar_primary </TT>

<TT>1998 B01> | unary_operator genvar_primary </TT>

<TT>1998 B01> | genvar_expression binary_operator genvar_expression </TT>

<TT>1998 B01> | genvar_expression ? genvar_expression : genvar_expression </TT>

<TT>1998 B01> | string </TT>

<TT>1998 B01><A NAME="genvar_primary"></A>genvar_primary ::= </TT>

<TT>1998 B01> constant_primary </TT>

<TT>1998 B01> | genvar_identifier </TT>

<TT>1998 B01> | genvar_identifier [ genvar_expression ] </TT>

<TT>1998 B01> | genvar_identifier [ msb_constant_expression : lsb_constant_expression ] </TT>

<TT>1998 B01> | genvar_concatenation | genvar_multiple_concatenation </TT>

<TT>1998 B01> | genvar_function_call </TT>

<TT>1998 B01><A NAME="genvar_function_call"></A>genvar_function_call ::= genvar_function_identifier ( genvar_expression { , genvar_expression } ) </TT>

<TT><A NAME="net_lvalue"></A>net_lvalue ::= </TT>