hyper-linked BNF

From: Adam Krolnik (adamk@cyrix.com)
Date: Mon Jul 20 1998 - 04:09:14 PDT

Next message: Karen L. Pieper: "Re: BTF - B13 - Mutable part selects proposal"
Previous message: Adam Krolnik: "Re: generate.html"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ] [ attachment ]

Here is the BNF with html links:
from definition to a usage.
from usage to the definition.

This shows immediately, definitions which have no usage. E.g. 'source_text'
as non-underlined definition.

It also shows names that aren't defined as non-underlined text (and non-bold.) E.g. 'scalar_expression' in "Primitive instances" is not defined.

It does not show circular references such as 'function_statement' which is referenced
but always within it's own definitions. This is one we will need to pick through -
or are there any ideas to identify this?

Adam

Begin forwarded message:

Date: Mon, 20 Jul 1998 16:46:34 -0500
From: adamk
To: adamk
Subject: hyper-linked BNF

<HTML>

<HEAD>

</HEAD>

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

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

<TT><A NAME="description" HREF="#Rdescription">description</A> ::= </TT>

<TT> <A NAME="Rmodule_declaration" HREF="#module_declaration">module_declaration</A> </TT>

<TT> | <A NAME="Rudp_declaration" HREF="#udp_declaration">udp_declaration</A> </TT>

<TT><A NAME="module_declaration" HREF="#Rmodule_declaration">module_declaration</A> ::= </TT>

<TT> <A NAME="Rmodule_keyword" HREF="#module_keyword">module_keyword</A> <A NAME="Rmodule_identifier" HREF="#module_identifier">module_identifier</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 </TT>

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

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

<TT> [ <A NAME="Rport_expression" HREF="#port_expression">port_expression</A> ] </TT>

<TT> | . <A NAME="Rport_identifier" HREF="#port_identifier">port_identifier</A> ( [ port_expression ] ) </TT>

<TT><A NAME="port_expression" HREF="#Rport_expression">port_expression</A> ::= </TT>

<TT> <A NAME="Rport_reference" HREF="#port_reference">port_reference</A> </TT>

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

<TT><A NAME="port_reference" HREF="#Rport_reference">port_reference</A> ::= </TT>

<TT> port_identifier </TT>

<TT> | port_identifier [ <A NAME="Rconstant_expression" HREF="#constant_expression">constant_expression</A> ] </TT>

<TT> | port_identifier [ <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> ] </TT>

<TT><A NAME="module_item" HREF="#Rmodule_item">module_item</A> ::= </TT>

<TT> <A NAME="Rmodule_item_declaration" HREF="#module_item_declaration">module_item_declaration</A> </TT>

<TT> | <A NAME="Rmodule_or_generate_item" HREF="#module_or_generate_item">module_or_generate_item</A> </TT>

<TT> | <A NAME="Rgenerated_instantiation" HREF="#generated_instantiation">generated_instantiation</A> </TT>

<TT> | <A NAME="Rspecify_block" HREF="#specify_block">specify_block</A> </TT>

<TT><A NAME="module_item_declaration" HREF="#Rmodule_item_declaration">module_item_declaration</A> ::= </TT>

<TT> <A NAME="Rparameter_declaration" HREF="#parameter_declaration">parameter_declaration</A> </TT>

<TT> | <A NAME="Rlocal_parameter_declaration" HREF="#local_parameter_declaration">local_parameter_declaration</A> </TT>

<TT> | <A NAME="Rinput_declaration" HREF="#input_declaration">input_declaration</A> </TT>

<TT> | <A NAME="Routput_declaration" HREF="#output_declaration">output_declaration</A> </TT>

<TT> | <A NAME="Rinout_declaration" HREF="#inout_declaration">inout_declaration</A> </TT>

<TT><A NAME="module_or_generate_item" HREF="#Rmodule_or_generate_item">module_or_generate_item</A> ::= </TT>

<TT> <A NAME="Rmodule_or_generate_item_declaration" HREF="#module_or_generate_item_declaration">module_or_generate_item_declaration</A> </TT>

<TT> | <A NAME="Rparameter_override" HREF="#parameter_override">parameter_override</A> </TT>

<TT> | <A NAME="Rcontinuous_assign" HREF="#continuous_assign">continuous_assign</A> </TT>

<TT> | <A NAME="Rgate_instantiation" HREF="#gate_instantiation">gate_instantiation</A> </TT>

<TT> | <A NAME="Rudp_instantiation" HREF="#udp_instantiation">udp_instantiation</A> </TT>

<TT> | <A NAME="Rmodule_instantiation" HREF="#module_instantiation">module_instantiation</A> </TT>

<TT> | <A NAME="Rinitial_construct" HREF="#initial_construct">initial_construct</A> </TT>

<TT> | <A NAME="Ralways_construct" HREF="#always_construct">always_construct</A> </TT>

<TT> | <A NAME="Ralways_combinational_construct" HREF="#always_combinational_construct">always_combinational_construct</A> </TT>

<TT><A NAME="module_or_generate_item_declaration" HREF="#Rmodule_or_generate_item_declaration">module_or_generate_item_declaration</A> ::= </TT>

<TT> <A NAME="Rnet_declaration" HREF="#net_declaration">net_declaration</A> </TT>

<TT> | <A NAME="Rreg_declaration" HREF="#reg_declaration">reg_declaration</A> </TT>

<TT> | <A NAME="Rinteger_declaration" HREF="#integer_declaration">integer_declaration</A> </TT>

<TT> | <A NAME="Rreal_declaration" HREF="#real_declaration">real_declaration</A> </TT>

<TT> | <A NAME="Rtime_declaration" HREF="#time_declaration">time_declaration</A> </TT>

<TT> | <A NAME="Rrealtime_declaration" HREF="#realtime_declaration">realtime_declaration</A> </TT>

<TT> | <A NAME="Revent_declaration" HREF="#event_declaration">event_declaration</A> </TT>

<TT> | <A NAME="Rtask_declaration" HREF="#task_declaration">task_declaration</A> </TT>

<TT> | <A NAME="Rfunction_declaration" HREF="#function_declaration">function_declaration</A> </TT>

<TT> | local_parameter_declaration </TT>

<TT><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> ; </TT>

<TT>A.2 Declarations </TT>

<TT><A NAME="parameter_declaration" HREF="#Rparameter_declaration">parameter_declaration</A> ::= parameter [ <A NAME="Rrange" HREF="#range">range</A> ] list_of_param_assignments ; </TT>

<TT><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 } </TT>

<TT><A NAME="local_parameter_declaration" HREF="#Rlocal_parameter_declaration">local_parameter_declaration</A> ::= localparam <A NAME="Rlist_of_local_param_assignments" HREF="#list_of_local_param_assignments">list_of_local_param_assignments</A> ; </TT>

<TT><A NAME="list_of_local_param_assignments" HREF="#Rlist_of_local_param_assignments">list_of_local_param_assignments</A> ::= param_assignment { , param_assignment } </TT>

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

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

<TT><A NAME="output_declaration" HREF="#Routput_declaration">output_declaration</A> ::= </TT>

<TT> output [ signed ] [ net_type ] [ range ] list_of_port_identifiers ; </TT>

<TT> | output [ signed ] [ <A NAME="Rreg_type" HREF="#reg_type">reg_type</A> ] [ range ] <A NAME="Rlist_of_reg_port_identifiers" HREF="#list_of_reg_port_identifiers">list_of_reg_port_identifiers</A> ; </TT>

<TT><A NAME="inout_declaration" HREF="#Rinout_declaration">inout_declaration</A> ::= inout [ signed ] [ net_type ] [ range ] list_of_port_identifiers ; </TT>

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

<TT><A NAME="list_of_reg_port_identifiers" HREF="#Rlist_of_reg_port_identifiers">list_of_reg_port_identifiers</A> ::= port_identifier [ = constant_expression ] { , port_identifier [ = constant_expression ] } </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><A NAME="reg_declaration" HREF="#Rreg_declaration">reg_declaration</A> ::= reg [ signed | unsigned ] [ range ] <A NAME="Rlist_of_regmem_identifiers" HREF="#list_of_regmem_identifiers">list_of_regmem_identifiers</A> ; </TT>

<TT><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> ; </TT>

<TT><A NAME="list_of_regmem_identifiers" HREF="#Rlist_of_regmem_identifiers">list_of_regmem_identifiers</A> ::= <A NAME="Rregister_name" HREF="#register_name">register_name</A> | <A NAME="Rmemory_name" HREF="#memory_name">memory_name</A> { , register_name | memory_name } </TT>

<TT><A NAME="list_of_register_identifiers" HREF="#Rlist_of_register_identifiers">list_of_register_identifiers</A> ::= register_name { , register_name } </TT>

<TT><A NAME="memory_name" HREF="#Rmemory_name">memory_name</A> ::= <A NAME="Rmemory_identifier" HREF="#memory_identifier">memory_identifier</A> [ <A NAME="Rupper_limit_constant_expression" HREF="#upper_limit_constant_expression">upper_limit_constant_expression</A> : <A NAME="Rlower_limit_constant_expression" HREF="#lower_limit_constant_expression">lower_limit_constant_expression</A> ] </TT>

<TT><A NAME="register_name" HREF="#Rregister_name">register_name</A> ::= <A NAME="Rregister_identifier" HREF="#register_identifier">register_identifier</A> [ <A NAME="Rdimension" HREF="#dimension">dimension</A> { , dimension }] </TT>

<TT><A NAME="list_of_real_identifiers" HREF="#Rlist_of_real_identifiers">list_of_real_identifiers</A> ::= <A NAME="Rreal_identifier" HREF="#real_identifier">real_identifier</A> [ dimension { , dimension }] { , real_identifier [ dimension { , dimension }] } </TT>

<TT><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 }] } </TT>

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

<TT><A NAME="dimension" HREF="#Rdimension">dimension</A> ::= [ <A NAME="Rdimension_constant_expression" HREF="#dimension_constant_expression">dimension_constant_expression</A> : dimension_constant_expression ] </TT>

<TT><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 }] } </TT>

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

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

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

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

<TT><A NAME="net_declaration" HREF="#Rnet_declaration">net_declaration</A> ::= </TT>

<TT> net_type [ vectored | scalared ] [ signed | unsigned ] [ range ] [ <A NAME="Rdelay3" HREF="#delay3">delay3</A> ] list_of_net_identifiers ; </TT>

<TT> | trireg [ vectored | scalared ] [ signed | unsigned ] [ <A NAME="Rcharge_strength" HREF="#charge_strength">charge_strength</A> ] [ range ] [ delay3 ] </TT>

<TT> list_of_net_identifiers ; </TT>

<TT> | net_type [ vectored | scalared ] [ signed | unsigned ] [ <A NAME="Rdrive_strength" HREF="#drive_strength">drive_strength</A> ] [ range ] [ delay3 ] </TT>

<TT> <A NAME="Rlist_of_net_decl_assignments" HREF="#list_of_net_decl_assignments">list_of_net_decl_assignments</A> ; </TT>

<TT><A NAME="drive_strength" HREF="#Rdrive_strength">drive_strength</A> ::= </TT>

<TT> ( <A NAME="Rstrength0" HREF="#strength0">strength0</A> , <A NAME="Rstrength1" HREF="#strength1">strength1</A> ) </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" HREF="#Rstrength0">strength0</A> ::= supply0 | strong0 | pull0 | weak0 </TT>

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

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

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

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

<TT><A NAME="delay_value" HREF="#Rdelay_value">delay_value</A> ::= <A NAME="Runsigned_number" HREF="#unsigned_number">unsigned_number</A> | parameter_identifier | <A NAME="Rconstant_mintypmax_expression" HREF="#constant_mintypmax_expression">constant_mintypmax_expression</A> </TT>

<TT><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 } </TT>

<TT><A NAME="net_decl_assignment" HREF="#Rnet_decl_assignment">net_decl_assignment</A> ::= net_identifier = <A NAME="Rexpression" HREF="#expression">expression</A> </TT>

<TT><A NAME="function_declaration" HREF="#Rfunction_declaration">function_declaration</A> ::= </TT>

<TT> function [signed] [ <A NAME="Rrange_or_type" HREF="#range_or_type">range_or_type</A> ] <A NAME="Rfunction_identifier" HREF="#function_identifier">function_identifier</A> ; </TT>

<TT> <A NAME="Rfunction_item_declaration" HREF="#function_item_declaration">function_item_declaration</A> { function_item_declaration } </TT>

<TT> <A NAME="Rstatement" HREF="#statement">statement</A> </TT>

<TT> endfunction </TT>

<TT><A NAME="reg_type" HREF="#Rreg_type">reg_type</A> ::= reg | integer | real | realtime | time </TT>

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

<TT><A NAME="function_item_declaration" HREF="#Rfunction_item_declaration">function_item_declaration</A> ::= </TT>

<TT> <A NAME="Rblock_item_declaration" HREF="#block_item_declaration">block_item_declaration</A> </TT>

<TT> | input_declaration </TT>

<TT>recursive_function_declaration ::= </TT>

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

<TT> <A NAME="Rrecursive_function_item_declaration" HREF="#recursive_function_item_declaration">recursive_function_item_declaration</A> { function_item_declaration } </TT>

<TT> statement </TT>

<TT> endfunction </TT>

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

<TT><A NAME="recursive_function_item_declaration" HREF="#Rrecursive_function_item_declaration">recursive_function_item_declaration</A> ::= </TT>

<TT> <A NAME="Rautomatic_block_item_declaration" HREF="#automatic_block_item_declaration">automatic_block_item_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_input_declaration" HREF="#automatic_input_declaration">automatic_input_declaration</A> </TT>

<TT><A NAME="task_declaration" HREF="#Rtask_declaration">task_declaration</A> ::= </TT>

<TT> task <A NAME="Rtask_identifier" HREF="#task_identifier">task_identifier</A> ; </TT>

<TT> { <A NAME="Rtask_item_declaration" HREF="#task_item_declaration">task_item_declaration</A> } </TT>

<TT> statement </TT>

<TT> endtask </TT>

<TT>combinational_task_declaration ::= </TT>

<TT> task <A NAME="Rcombinational_task_identifier" HREF="#combinational_task_identifier">combinational_task_identifier</A> ; </TT>

<TT> { task_item_declaration } </TT>

<TT> <A NAME="Rcombinational_statement" HREF="#combinational_statement">combinational_statement</A> </TT>

<TT> endtask </TT>

<TT><A NAME="task_item_declaration" HREF="#Rtask_item_declaration">task_item_declaration</A> ::= </TT>

<TT> block_item_declaration </TT>

<TT> | input_declaration </TT>

<TT> | output_declaration </TT>

<TT> | inout_declaration </TT>

<TT><A NAME="block_item_declaration" HREF="#Rblock_item_declaration">block_item_declaration</A> ::= </TT>

<TT> parameter_declaration </TT>

<TT> | 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>recursive_reentrant_task_declaration ::= </TT>

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

<TT> { <A NAME="Rrecursive_reentrant_task_item_declaration" HREF="#recursive_reentrant_task_item_declaration">recursive_reentrant_task_item_declaration</A> } </TT>

<TT> statement </TT>

<TT> endtask </TT>

<TT><A NAME="recursive_reentrant_task_item_declaration" HREF="#Rrecursive_reentrant_task_item_declaration">recursive_reentrant_task_item_declaration</A> ::= </TT>

<TT> automatic_block_item_declaration </TT>

<TT> | automatic_input_declaration </TT>

<TT> | <A NAME="Rautomatic_output_declaration" HREF="#automatic_output_declaration">automatic_output_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_inout_declaration" HREF="#automatic_inout_declaration">automatic_inout_declaration</A> </TT>

<TT><A NAME="automatic_block_item_declaration" HREF="#Rautomatic_block_item_declaration">automatic_block_item_declaration</A> ::= </TT>

<TT> parameter_declaration </TT>

<TT> | local_parameter_declaration </TT>

<TT> | <A NAME="Rautomatic_reg_declaration" HREF="#automatic_reg_declaration">automatic_reg_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_integer_declaration" HREF="#automatic_integer_declaration">automatic_integer_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_time_declaration" HREF="#automatic_time_declaration">automatic_time_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_real_declaration" HREF="#automatic_real_declaration">automatic_real_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_realtime_declaration" HREF="#automatic_realtime_declaration">automatic_realtime_declaration</A> </TT>

<TT> | <A NAME="Rautomatic_event_declaration" HREF="#automatic_event_declaration">automatic_event_declaration</A> </TT>

<TT><A NAME="automatic_input_declaration" HREF="#Rautomatic_input_declaration">automatic_input_declaration</A> ::= input [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT><A NAME="automatic_output_declaration" HREF="#Rautomatic_output_declaration">automatic_output_declaration</A> ::= output [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT><A NAME="automatic_inout_declaration" HREF="#Rautomatic_inout_declaration">automatic_inout_declaration</A> ::= inout [ automatic ] [ signed ] list_of_port_identifiers ; </TT>

<TT><A NAME="automatic_reg_declaration" HREF="#Rautomatic_reg_declaration">automatic_reg_declaration</A> ::= reg [ automatic ] [ signed | unsigned ] [range] list_of_regmem_identifiers ; </TT>

<TT><A NAME="automatic_integer_declaration" HREF="#Rautomatic_integer_declaration">automatic_integer_declaration</A> ::= integer [ automatic ] list_of_register_identifiers ; </TT>

<TT><A NAME="automatic_time_declaration" HREF="#Rautomatic_time_declaration">automatic_time_declaration</A> ::= time [ automatic ] list_of_register_identifiers ; </TT>

<TT><A NAME="automatic_real_declaration" HREF="#Rautomatic_real_declaration">automatic_real_declaration</A> ::= real [ automatic ] list_of_real_identifiers ; </TT>

<TT><A NAME="automatic_realtime_declaration" HREF="#Rautomatic_realtime_declaration">automatic_realtime_declaration</A> ::= realtime [ automatic ] list_of_real_identifiers ; </TT>

<TT><A NAME="automatic_event_declaration" HREF="#Rautomatic_event_declaration">automatic_event_declaration</A> ::= event [ automatic ] list_of_event_identifiers ; </TT>

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

<TT><A NAME="gate_instantiation" HREF="#Rgate_instantiation">gate_instantiation</A> ::= </TT>

<TT> <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | <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 } ; </TT>

<TT> | pullup [<A NAME="Rpullup_strength" HREF="#pullup_strength">pullup_strength</A>] <A NAME="Rpull_gate_instance" HREF="#pull_gate_instance">pull_gate_instance</A> { , pull_gate_instance } ; </TT>

<TT> | pulldown [<A NAME="Rpulldown_strength" HREF="#pulldown_strength">pulldown_strength</A>] pull_gate_instance { , pull_gate_instance } ; </TT>

<TT><A NAME="n_input_gate_instance" HREF="#Rn_input_gate_instance">n_input_gate_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> { , input_terminal } ) </TT>

<TT><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 ) </TT>

<TT><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> ) </TT>

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

<TT><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 ) </TT>

<TT><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 ) </TT>

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

<TT> <A NAME="Rncontrol_terminal" HREF="#ncontrol_terminal">ncontrol_terminal</A> , <A NAME="Rpcontrol_terminal" HREF="#pcontrol_terminal">pcontrol_terminal</A>) </TT>

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

<TT><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] </TT>

<TT><A NAME="pullup_strength" HREF="#Rpullup_strength">pullup_strength</A> ::= </TT>

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

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

<TT> | ( strength1 ) </TT>

<TT><A NAME="pulldown_strength" HREF="#Rpulldown_strength">pulldown_strength</A> ::= </TT>

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

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

<TT> | ( strength0 ) </TT>

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

<TT><A NAME="enable_terminal" HREF="#Renable_terminal">enable_terminal</A> ::= scalar_expression </TT>

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

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

<TT><A NAME="output_terminal" HREF="#Routput_terminal">output_terminal</A> ::= <A NAME="Rterminal_identifier" HREF="#terminal_identifier">terminal_identifier</A> | terminal_identifier [ constant_expression ] </TT>

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

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

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

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

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

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

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

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

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

<TT><A NAME="module_instantiation" HREF="#Rmodule_instantiation">module_instantiation</A> ::= </TT>

<TT> 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 } ; </TT>

<TT><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> ) </TT>

<TT><A NAME="list_of_parameter_assignments" HREF="#Rlist_of_parameter_assignments">list_of_parameter_assignments</A> ::= </TT>

<TT> <A NAME="Rordered_parameter_assignment" HREF="#ordered_parameter_assignment">ordered_parameter_assignment</A> { , ordered_parameter_assignment } | </TT>

<TT> <A NAME="Rnamed_parameter_assignment" HREF="#named_parameter_assignment">named_parameter_assignment</A> { , named_parameter_assignment } </TT>

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

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

<TT><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_module_connections" HREF="#list_of_module_connections">list_of_module_connections</A>] ) </TT>

<TT><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 ] </TT>

<TT><A NAME="list_of_module_connections" HREF="#Rlist_of_module_connections">list_of_module_connections</A> ::= </TT>

<TT> <A NAME="Rordered_port_connection" HREF="#ordered_port_connection">ordered_port_connection</A> { , ordered_port_connection } </TT>

<TT> | <A NAME="Rnamed_port_connection" HREF="#named_port_connection">named_port_connection</A> { , named_port_connection } </TT>

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

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

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

<TT><A NAME="list_of_genvar_identifiers" HREF="#Rlist_of_genvar_identifiers">list_of_genvar_identifiers</A> ::= </TT>

<TT> <A NAME="Rgenvar_identifier" HREF="#genvar_identifier">genvar_identifier</A> { , genvar_identifier } </TT>

<TT><A NAME="generated_instantiation" HREF="#Rgenerated_instantiation">generated_instantiation</A> ::= generate { <A NAME="Rgenerate_item" HREF="#generate_item">generate_item</A> } endgenerate </TT>

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

<TT><A NAME="generate_item" HREF="#Rgenerate_item">generate_item</A> ::= </TT>

<TT> <A NAME="Rgenerate_conditional_statement" HREF="#generate_conditional_statement">generate_conditional_statement</A> </TT>

<TT> | <A NAME="Rgenerate_case_statement" HREF="#generate_case_statement">generate_case_statement</A> </TT>

<TT> | <A NAME="Rgenerate_loop_statement" HREF="#generate_loop_statement">generate_loop_statement</A> </TT>

<TT> | <A NAME="Rgenerate_block" HREF="#generate_block">generate_block</A> </TT>

<TT> | module_or_generate_item </TT>

<TT><A NAME="generate_conditional_statement" HREF="#Rgenerate_conditional_statement">generate_conditional_statement</A> ::= </TT>

<TT> if ( <A NAME="Rgenvar_expression" HREF="#genvar_expression">genvar_expression</A> ) generate_item_or_null [ else generate_item_or_null ] </TT>

<TT><A NAME="generate_case_statement" HREF="#Rgenerate_case_statement">generate_case_statement</A> ::= case ( genvar_expression ) </TT>

<TT><A NAME="Rgenvar_case_item" HREF="#genvar_case_item">genvar_case_item</A> { genvar_case_item } endcase </TT>

<TT><A NAME="genvar_case_item" HREF="#Rgenvar_case_item">genvar_case_item</A> ::= genvar_expression { , genvar_expression } : </TT>

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

<TT><A NAME="generate_loop_statement" HREF="#Rgenerate_loop_statement">generate_loop_statement</A> ::= for ( <A NAME="Rgenvar_assignment" HREF="#genvar_assignment">genvar_assignment</A> ; genvar_expression ; genvar_assignment ) generate_item </TT>

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

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

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

<TT><A NAME="udp_declaration" HREF="#Rudp_declaration">udp_declaration</A> ::= </TT>

<TT> primitive <A NAME="Rudp_identifier" HREF="#udp_identifier">udp_identifier</A> [ ( <A NAME="Rudp_port_list" HREF="#udp_port_list">udp_port_list</A> ) ] ; </TT>

<TT> <A NAME="Rudp_port_declaration" HREF="#udp_port_declaration">udp_port_declaration</A> { udp_port_declaration } </TT>

<TT> endprimitive </TT>

<TT><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 } </TT>

<TT><A NAME="udp_port_declaration" HREF="#Rudp_port_declaration">udp_port_declaration</A> ::= </TT>

<TT> <A NAME="Rudp_output_declaration" HREF="#udp_output_declaration">udp_output_declaration</A> </TT>

<TT> | <A NAME="Rudp_input_declaration" HREF="#udp_input_declaration">udp_input_declaration</A> </TT>

<TT> | <A NAME="Rudp_reg_declaration" HREF="#udp_reg_declaration">udp_reg_declaration</A> </TT>

<TT><A NAME="udp_output_declaration" HREF="#Rudp_output_declaration">udp_output_declaration</A> ::= </TT>

<TT> output port_identifier ; </TT>

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

<TT><A NAME="udp_input_declaration" HREF="#Rudp_input_declaration">udp_input_declaration</A> ::= </TT>

<TT> input list_of_port_identifiers ; </TT>

<TT><A NAME="udp_reg_declaration" HREF="#Rudp_reg_declaration">udp_reg_declaration</A> ::= reg register_identifier ; </TT>

<TT><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> </TT>

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

<TT><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> ; </TT>

<TT><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 </TT>

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

<TT><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> ; </TT>

<TT><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> </TT>

<TT><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 } </TT>

<TT><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 } </TT>

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

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

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

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

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

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

<TT><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 } ; </TT>

<TT><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_port_connection , input_port_connection </TT>

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

<TT><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 ] </TT>

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

<TT><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> ; </TT>

<TT><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 } </TT>

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

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

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

<TT><A NAME="always_combinational_construct" HREF="#Ralways_combinational_construct">always_combinational_construct</A> ::= always @* combinational_statement </TT>

<TT><A NAME="statement" HREF="#Rstatement">statement</A> ::= </TT>

<TT> <A NAME="Rblocking_assignment" HREF="#blocking_assignment">blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rnon_blocking_assignment" HREF="#non_blocking_assignment">non_blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rprocedural_continuous_assignments" HREF="#procedural_continuous_assignments">procedural_continuous_assignments</A> ; </TT>

<TT> | <A NAME="Rprocedural_timing_control_statement" HREF="#procedural_timing_control_statement">procedural_timing_control_statement</A> </TT>

<TT> | <A NAME="Rconditional_statement" HREF="#conditional_statement">conditional_statement</A> </TT>

<TT> | <A NAME="Rcase_statement" HREF="#case_statement">case_statement</A> </TT>

<TT> | <A NAME="Rloop_statement" HREF="#loop_statement">loop_statement</A> </TT>

<TT> | <A NAME="Rwait_statement" HREF="#wait_statement">wait_statement</A> </TT>

<TT> | <A NAME="Rdisable_statement" HREF="#disable_statement">disable_statement</A> </TT>

<TT> | <A NAME="Revent_trigger" HREF="#event_trigger">event_trigger</A> </TT>

<TT> | <A NAME="Rseq_block" HREF="#seq_block">seq_block</A> </TT>

<TT> | <A NAME="Rpar_block" HREF="#par_block">par_block</A> </TT>

<TT> | <A NAME="Rtask_enable" HREF="#task_enable">task_enable</A> </TT>

<TT> | <A NAME="Rsystem_task_enable" HREF="#system_task_enable">system_task_enable</A> </TT>

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

<TT><A NAME="blocking_assignment" HREF="#Rblocking_assignment">blocking_assignment</A> ::= <A NAME="Rreg_lvalue" HREF="#reg_lvalue">reg_lvalue</A> = [ <A NAME="Rdelay_or_event_control" HREF="#delay_or_event_control">delay_or_event_control</A> ] expression </TT>

<TT><A NAME="non_blocking_assignment" HREF="#Rnon_blocking_assignment">non_blocking_assignment</A> ::= reg_lvalue <= [ delay_or_event_control ] expression </TT>

<TT><A NAME="procedural_continuous_assignments" HREF="#Rprocedural_continuous_assignments">procedural_continuous_assignments</A> ::= </TT>

<TT> assign <A NAME="Rreg_assignment" HREF="#reg_assignment">reg_assignment</A> ; </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" HREF="#Rprocedural_timing_control_statement">procedural_timing_control_statement</A> ::= </TT>

<TT> delay_or_event_control statement_or_null </TT>

<TT><A NAME="combinational_statement" HREF="#Rcombinational_statement">combinational_statement</A> ::= </TT>

<TT> <A NAME="Rcombinational_blocking_assignment" HREF="#combinational_blocking_assignment">combinational_blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rcombinational_non_blocking_assignment" HREF="#combinational_non_blocking_assignment">combinational_non_blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rcombinational_procedural_timing_control_statement" HREF="#combinational_procedural_timing_control_statement">combinational_procedural_timing_control_statement</A> </TT>

<TT> | <A NAME="Rcombinational_conditional_statement" HREF="#combinational_conditional_statement">combinational_conditional_statement</A> </TT>

<TT> | <A NAME="Rcombinational_case_statement" HREF="#combinational_case_statement">combinational_case_statement</A> </TT>

<TT> | <A NAME="Rcombinational_loop_statement" HREF="#combinational_loop_statement">combinational_loop_statement</A> </TT>

<TT> | disable_statement </TT>

<TT> | <A NAME="Rcombinational_seq_block" HREF="#combinational_seq_block">combinational_seq_block</A> </TT>

<TT> | <A NAME="Rcombinational_task_enable" HREF="#combinational_task_enable">combinational_task_enable</A> </TT>

<TT> | system_task_enable </TT>

<TT><A NAME="combinational_statement_or_null" HREF="#Rcombinational_statement_or_null">combinational_statement_or_null</A> ::= combinational_statement | ; </TT>

<TT><A NAME="combinational_blocking_assignment" HREF="#Rcombinational_blocking_assignment">combinational_blocking_assignment</A> ::= reg_lvalue = [ <A NAME="Rdelay_control" HREF="#delay_control">delay_control</A> ] expression </TT>

<TT><A NAME="combinational_non_blocking_assignment" HREF="#Rcombinational_non_blocking_assignment">combinational_non_blocking_assignment</A> ::= reg_lvalue <= [ delay_control ] expression </TT>

<TT><A NAME="combinational_procedural_timing_control_statement" HREF="#Rcombinational_procedural_timing_control_statement">combinational_procedural_timing_control_statement</A> ::= </TT>

<TT> delay_control combinational_statement_or_null </TT>

<TT><A NAME="function_statement" HREF="#Rfunction_statement">function_statement</A> ::= </TT>

<TT> <A NAME="Rfunction_blocking_assignment" HREF="#function_blocking_assignment">function_blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rfunction_non_blocking_assignment" HREF="#function_non_blocking_assignment">function_non_blocking_assignment</A> ; </TT>

<TT> | <A NAME="Rfunction_conditional_statement" HREF="#function_conditional_statement">function_conditional_statement</A> </TT>

<TT> | <A NAME="Rfunction_case_statement" HREF="#function_case_statement">function_case_statement</A> </TT>

<TT> | <A NAME="Rfunction_loop_statement" HREF="#function_loop_statement">function_loop_statement</A> </TT>

<TT> | disable_statement </TT>

<TT> | combinational_seq_block </TT>

<TT> | system_task_enable </TT>

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

<TT><A NAME="function_non_blocking_assignment" HREF="#Rfunction_non_blocking_assignment">function_non_blocking_assignment</A> ::= reg_lvalue <= [ delay_control ] expression </TT>

<TT><A NAME="function_statement_or_null" HREF="#Rfunction_statement_or_null">function_statement_or_null</A> ::= function_statement | ; </TT>

<TT><A NAME="delay_or_event_control" HREF="#Rdelay_or_event_control">delay_or_event_control</A> ::= </TT>

<TT> delay_control </TT>

<TT> | <A NAME="Revent_control" HREF="#event_control">event_control</A> </TT>

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

<TT><A NAME="delay_control" HREF="#Rdelay_control">delay_control</A> ::= </TT>

<TT> # delay_value </TT>

<TT> | # ( <A NAME="Rmintypmax_expression" HREF="#mintypmax_expression">mintypmax_expression</A> ) </TT>

<TT><A NAME="event_control" HREF="#Revent_control">event_control</A> ::= </TT>

<TT> @ event_identifier </TT>

<TT> | @ ( <A NAME="Revent_expression" HREF="#event_expression">event_expression</A> ) </TT>

<TT><A NAME="event_expression" HREF="#Revent_expression">event_expression</A> ::= </TT>

<TT> expression </TT>

<TT> | event_identifier </TT>

<TT> | posedge expression </TT>

<TT> | negedge expression </TT>

<TT> | event_expression or event_expression </TT>

<TT> | event_expression , event_expression </TT>

<TT><A NAME="conditional_statement" HREF="#Rconditional_statement">conditional_statement</A> ::= </TT>

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

<TT><A NAME="case_statement" HREF="#Rcase_statement">case_statement</A> ::= </TT>

<TT> case ( expression ) <A NAME="Rcase_item" HREF="#case_item">case_item</A> [ 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" HREF="#Rloop_statement">loop_statement</A> ::= </TT>

<TT> forever statement </TT>

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

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

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

<TT><A NAME="combinational_conditional_statement" HREF="#Rcombinational_conditional_statement">combinational_conditional_statement</A> ::= </TT>

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

<TT><A NAME="combinational_case_statement" HREF="#Rcombinational_case_statement">combinational_case_statement</A> ::= </TT>

<TT> case ( expression ) case_item [ <A NAME="Rcombinational_case_item" HREF="#combinational_case_item">combinational_case_item</A> ] endcase </TT>

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

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

<TT><A NAME="combinational_case_item" HREF="#Rcombinational_case_item">combinational_case_item</A> ::= </TT>

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

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

<TT><A NAME="combinational_loop_statement" HREF="#Rcombinational_loop_statement">combinational_loop_statement</A> ::= </TT>

<TT> forever combinational_statement </TT>

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

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

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

<TT><A NAME="combinational_seq_block" HREF="#Rcombinational_seq_block">combinational_seq_block</A> ::= begin [ : <A NAME="Rblock_identifier" HREF="#block_identifier">block_identifier</A> { block_item_declaration } ] { combinational_statement } end </TT>

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

<TT><A NAME="function_conditional_statement" HREF="#Rfunction_conditional_statement">function_conditional_statement</A> ::= </TT>

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

<TT><A NAME="function_case_statement" HREF="#Rfunction_case_statement">function_case_statement</A> ::= </TT>

<TT> case ( expression ) case_item [ <A NAME="Rfunction_case_item" HREF="#function_case_item">function_case_item</A> ] endcase </TT>

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

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

<TT><A NAME="function_case_item" HREF="#Rfunction_case_item">function_case_item</A> ::= </TT>

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

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

<TT><A NAME="function_loop_statement" HREF="#Rfunction_loop_statement">function_loop_statement</A> ::= </TT>

<TT> forever function_statement </TT>

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

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

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

<TT>function_seq_block ::= begin [ : block_identifier { block_item_declaration } ] { function_statement } end </TT>

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

<TT><A NAME="wait_statement" HREF="#Rwait_statement">wait_statement</A> ::= </TT>

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

<TT><A NAME="event_trigger" HREF="#Revent_trigger">event_trigger</A> ::= </TT>

<TT> -> event_identifier ; </TT>

<TT><A NAME="disable_statement" HREF="#Rdisable_statement">disable_statement</A> ::= </TT>

<TT> disable task_identifier ; </TT>

<TT> | disable block_identifier ; </TT>

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

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

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

<TT><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 } ) ] ; </TT>

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

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

<TT><A NAME="specify_item" HREF="#Rspecify_item">specify_item</A> ::= </TT>

<TT> <A NAME="Rspecparam_declaration" HREF="#specparam_declaration">specparam_declaration</A> </TT>

<TT> | <A NAME="Rpath_declaration" HREF="#path_declaration">path_declaration</A> </TT>

<TT> | <A NAME="Rsystem_timing_check" HREF="#system_timing_check">system_timing_check</A> </TT>

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

<TT><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 } </TT>

<TT><A NAME="specparam_assignment" HREF="#Rspecparam_assignment">specparam_assignment</A> ::= </TT>

<TT> <A NAME="Rspecparam_identifier" HREF="#specparam_identifier">specparam_identifier</A> = constant_mintypmax_expression </TT>

<TT> | <A NAME="Rpulse_control_specparam" HREF="#pulse_control_specparam">pulse_control_specparam</A> </TT>

<TT><A NAME="pulse_control_specparam" HREF="#Rpulse_control_specparam">pulse_control_specparam</A> ::= </TT>

<TT> 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> ] ) ; </TT>

<TT> | 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> </TT>

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

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

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

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

<TT><A NAME="path_declaration" HREF="#Rpath_declaration">path_declaration</A> ::= </TT>

<TT> <A NAME="Rsimple_path_declaration" HREF="#simple_path_declaration">simple_path_declaration</A> ; </TT>

<TT> | <A NAME="Redge_sensitive_path_declaration" HREF="#edge_sensitive_path_declaration">edge_sensitive_path_declaration</A> ; </TT>

<TT> | <A NAME="Rstate_dependent_path_declaration" HREF="#state_dependent_path_declaration">state_dependent_path_declaration</A> ; </TT>

<TT><A NAME="simple_path_declaration" HREF="#Rsimple_path_declaration">simple_path_declaration</A> ::= </TT>

<TT> <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> </TT>

<TT> | <A NAME="Rfull_path_description" HREF="#full_path_description">full_path_description</A> = path_delay_value </TT>

<TT><A NAME="parallel_path_description" HREF="#Rparallel_path_description">parallel_path_description</A> ::= </TT>

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

<TT><A NAME="full_path_description" HREF="#Rfull_path_description">full_path_description</A> ::= </TT>

<TT> ( <A NAME="Rlist_of_path_inputs" HREF="#list_of_path_inputs">list_of_path_inputs</A> [ polarity_operator ] *> <A NAME="Rlist_of_path_outputs" HREF="#list_of_path_outputs">list_of_path_outputs</A> ) </TT>

<TT><A NAME="list_of_path_inputs" HREF="#Rlist_of_path_inputs">list_of_path_inputs</A> ::= </TT>

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

<TT><A NAME="list_of_path_outputs" HREF="#Rlist_of_path_outputs">list_of_path_outputs</A> ::= </TT>

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

<TT><A NAME="specify_input_terminal_descriptor" HREF="#Rspecify_input_terminal_descriptor">specify_input_terminal_descriptor</A> ::= </TT>

<TT> <A NAME="Rinput_identifier" HREF="#input_identifier">input_identifier</A> </TT>

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

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

<TT><A NAME="specify_output_terminal_descriptor" HREF="#Rspecify_output_terminal_descriptor">specify_output_terminal_descriptor</A> ::= </TT>

<TT> <A NAME="Routput_identifier" HREF="#output_identifier">output_identifier</A> </TT>

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

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

<TT><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> </TT>

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

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

<TT><A NAME="path_delay_value" HREF="#Rpath_delay_value">path_delay_value</A> ::= </TT>

<TT> <A NAME="Rlist_of_path_delay_expressions" HREF="#list_of_path_delay_expressions">list_of_path_delay_expressions</A> </TT>

<TT> | ( list_of_path_delay_expressions ) </TT>

<TT><A NAME="list_of_path_delay_expressions" HREF="#Rlist_of_path_delay_expressions">list_of_path_delay_expressions</A> ::= </TT>

<TT> <A NAME="Rt_path_delay_expression" HREF="#t_path_delay_expression">t_path_delay_expression</A> </TT>

<TT> | <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> </TT>

<TT> | trise_path_delay_expression , tfall_path_delay_expression , <A NAME="Rtz_path_delay_expression" HREF="#tz_path_delay_expression">tz_path_delay_expression</A> </TT>

<TT> | <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> , </TT>

<TT> <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> </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> <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> , </TT>

<TT> <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> </TT>

<TT><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> </TT>

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

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

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

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

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

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

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

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

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

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

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

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

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

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