VHDL-AMS Syntax (IEEE Std 1076.1)

Quick Find: a b c d e f g h i j k l m n o p q r s t u v w x y z keywords attributes

The start symbol is design_file.

Syntax:

abstract_literal ::=

decimal_literal | based_literal

access_type_definition ::=

access subtype_indication

across_aspect ::=

identifier_list [ tolerance_aspect ] [ := expression ] across

actual_designator ::=

expression
| signal_name
| variable_name
| file_name
| terminal_name
| quantity_name
| open

actual_parameter_part ::=

parameter_association_list

actual_part ::=

actual_designator
| function_name ( actual_designator )
| type_mark ( actual_designator )

adding_operator ::=

+ | - | &

aggregate ::=

( element_association { , element_association } )

alias_declaration ::=

alias alias_designator [ : alias_indication ] is name [ signature ] ;

alias_designator ::=

identifier
| character_literal
| operator_symbol

alias_indication ::=

subtype_indication
| subnature_indication

allocator ::=

new subtype_indication
| new qualified_expression

architecture_body ::=

architecture identifier of entity_name is

architecture_declarative_part

begin

architecture_statement_part

end [ architecture ] [ architecture_simple_name ] ;

architecture_declarative_part ::=

{ block_declarative_item }

architecture_statement ::=

simultaneous_statement
| concurrent_statement

architecture_statement_part ::=

{ architecture_statement }

array_nature_definition ::=

unconstrained_nature_definition | constrained_nature_definition

array_type_definition ::=

unconstrained_array_definition | constrained_array_definition

assertion ::=

assert condition

[ report expression ]
[ severity expression ]

assertion_statement ::=

[ label : ] assertion ;

association_element ::=

[ formal_part => ] actual_part

association_list ::=

association_element { , association_element }

attribute_declaration ::=

attribute identifier : type_mark ;

attribute_designator ::=

attribute_simple_name

attribute_name ::=

prefix [ signature ] ' attribute_designator [ ( expression { , expression } ) ]

attribute_specification ::=

attribute attribute_designator of entity_specification is expression ;

base ::=

integer

base_specifier ::=

B | O | X

based_integer ::=

extended_digit { [underline ] extended_digit }

based_literal ::=

base # based_integer [ . based_integer ] # [ exponent ]

basic_character ::=

basic_graphic_character | format_effector

basic_graphic_character ::=

upper_case_letter | digit | special_character | space_character

basic_identifier ::=

letter { [ underline ] letter_or_digit }

binding_indication ::=

[ use entity_aspect ]
[ generic_map_aspect ]
[ port_map_aspect ]

bit_string_literal ::=

base_specifier " [ bit_value ] "

bit_value ::=

extended_digit { [ underline ] extended_digit }

block_configuration ::=

for block_specification

{ use_clause }
{ configuration_item }

end for ;

block_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| signal_declaration
| shared_variable_declaration
| file_declaration
| alias_declaration
| component_declaration
| attribute_declaration
| attribute_specification
| configuration_specification
| disconnection_specification
| step_limit_specification
| use_clause
| group_template_declaration
| group_declaration
| nature_declaration
| subnature_declaration
| quantity_declaration
| terminal_declaration

block_declarative_part ::=

{ block_declarative_item }

block_header ::=

[ generic_clause
[ generic_map_aspect ; ] ]
[ port_clause
[ port_map_aspect ; ] ]

block_specification ::=

architecture_name
| block_statement_label
| generate_statement_label [ ( index_specification ) ]

block_statement ::=

block_label :

block [ ( guard_expression ) ] [ is ]
block_header
block_declarative_part
begin
block_statement_part
end block [ block_label ] ;

block_statement_part ::=

{ architecture_statement }

branch_quantity_declaration ::=

quantity [ across_aspect ] [ through_aspect ] terminal_aspect ;

break_element ::=

[ break_selector_clause ] quantity_name => expression

break_list ::=

break_element { , break_element }

break_selector_clause ::=

for quantity_name use

break_statement ::=

[ label : ] break [ break_list ] [ when condition ] ;

case_statement ::=

[ case_label : ]

case expression is
case_statement_alternative
{ case_statement_alternative }
end case [ case_label ] ;

case_statement_alternative ::=

when choices =>

sequence_of_statements

character_literal ::=

' graphic_character '

choice ::=

simple_expression
| discrete_range
| element_simple_name
| others

choices ::=

choice { | choice }

component_configuration ::=

for component_specification

[ binding_indication ; ]
[ block_configuration ]

end for ;

component_declaration ::=

component identifier [ is ]

[ local_generic_clause ]
[ local_port_clause ]

end component [ component_simple_name ] ;

component_instantiation_statement ::=

instantiation_label :

instantiated_unit
[ generic_map_aspect ]
[ port_map_aspect ] ;

component_specification ::=

instantiation_list : component_name

composite_nature_definition ::=

array_nature_definition
| record_nature_definition

composite_type_definition ::=

array_type_definition
| record_type_definition

concurrent_assertion_statement ::=

[ label : ] [ postponed ] assertion ;

concurrent_break_statement ::=

[ label : ] break [ break_list ] [ sensitivity_clause ] [ when condition ] ;

concurrent_procedure_call_statement ::=

[ label : ] [ postponed ] procedure_call ;

concurrent_signal_assignment_statement ::=

[ label : ] [ postponed ] conditional_signal_assignment
| [ label : ] [ postponed ] selected_signal_assignment

concurrent_statement ::=

block_statement
| process_statement
| concurrent_procedure_call_statement
| concurrent_assertion_statement
| concurrent_signal_assignment_statement
| component_instantiation_statement
| generate_statement
| concurrent_break_statement

condition ::=

boolean_expression

condition_clause ::=

until condition

conditional_signal_assignment ::=

target <= options conditional_waveforms ;

conditional_waveforms ::=

{ waveform when condition else }
waveform [ when condition ]

configuration_declaration ::=

configuration identifier of entity_name is

configuration_declarative_part
block_configuration

end [ configuration ] [ configuration_simple_name ] ;

configuration_declarative_item ::=

use_clause
| attribute_specification
| group_declaration

configuration_declarative_part ::=

{ configuration_declarative_item }

configuration_item ::=

block_configuration
| component_configuration

configuration_specification ::=

for component_specification binding_indication ;

constant_declaration ::=

constant identifier_list : subtype_indication [ := expression ] ;

constrained_array_definition ::=

array index_constraint of element_subtype_indication

constrained_nature_definition ::=

array index_constraint of subnature_indication

constraint ::=

range_constraint
| index_constraint

context_clause ::=

{ context_item }

context_item ::=

library_clause
| use_clause

decimal_literal ::=

integer [ . integer ] [ exponent ]

declaration ::=

type_declaration
| subtype_declaration
| object_declaration
| interface_declaration
| alias_declaration
| attribute_declaration
| component_declaration
| group_template_declaration
| group_declaration
| entity_declaration
| configuration_declaration
| subprogram_declaration
| package_declaration
| nature_declaration
| subnature_declaration
| quantity_declaration
| terminal_declaration

delay_mechanism ::=

transport
| [ reject time_expression ] inertial

design_file ::=

design_unit { design_unit }

design_unit ::=

context_clause library_unit

designator ::=

identifier | operator_symbol

direction ::=

to | downto

disconnection_specification ::=

disconnect guarded_signal_specification after time_expression ;

discrete_range ::=

discrete_subtype_indication | range

element_association ::=

[ choices => ] expression

element_declaration ::=

identifier_list : element_subtype_definition ;

element_subnature_definition ::=

subnature_indication

element_subtype_definition ::=

subtype_indication

entity_aspect ::=

entity entity_name [ ( architecture_identifier ) ]
| configuration configuration_name
| open

entity_class ::=

entity
| architecture
| configuration
| procedure
| function
| package
| type
| subtype
| constant
| signal
| variable
| component
| label
| literal
| units
| group
| file
| nature
| subnature
| quantity
| terminal

entity_class_entry ::=

entity_class [ <> ]

entity_class_entry_list ::=

entity_class_entry { , entity_class_entry }

entity_declaration ::=

entity identifier is

entity_header
entity_declarative_part

[ begin

entity_statement_part ]

end [ entity ] [ entity_simple_name ] ;

entity_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| signal_declaration
| shared_variable_declaration
| file_declaration
| alias_declaration
| attribute_declaration
| attribute_specification
| disconnection_specification
| step_limit_specification
| use_clause
| group_template_declaration
| group_declaration
| nature_declaration
| subnature_declaration
| quantity_declaration
| terminal_declaration

entity_declarative_part ::=

{ entity_declarative_item }

entity_designator ::=

entity_tag [ signature ]

entity_header ::=

[ formal_generic_clause ]
[ formal_port_clause ]

entity_name_list ::=

entity_designator { , entity_designator }
| others
| all

entity_specification ::=

entity_name_list : entity_class

entity_statement ::=

concurrent_assertion_statement
| passive_concurrent_procedure_call_statement
| passive_process_statement

entity_statement_part ::=

{ entity_statement }

entity_tag ::=

simple_name
| character_literal
| operator_symbol

enumeration_literal ::=

identifier | character_literal

enumeration_type_definition ::=

( enumeration_literal { , enumeration_literal } )

exit_statement ::=

[ label : ] exit [ loop_label ] [ when condition ] ;

exponent ::=

E [ + ] integer | E - integer

expression ::=

relation { and relation }
| relation { or relation }
| relation { xor relation }
| relation [ nand relation ]
| relation [ nor relation ]
| relation { xnor relation }

extended_digit ::=

digit | letter

extended_identifier ::=

\ graphic_character { graphic_character } \

factor ::=

primary [ ** primary ]
| abs primary
| not primary

file_declaration ::=

file identifier_list : subtype_indication [ file_open_information ] ;

file_logical_name ::=

string_expression

file_open_information ::=

[ open file_open_kind_expression ] is file_logical_name

file_type_definition ::=

file of type_mark

floating_type_definition ::=

range_constraint

formal_designator ::=

generic_name
| port_name
| parameter_name

formal_parameter_list ::=

parameter_interface_list

formal_part ::=

formal_designator
| function_name ( formal_designator )
| type_mark ( formal_designator )

free_quantity_declaration ::=

quantity identifier_list : subtype_indication [ := expression ] ;

full_type_declaration ::=

type identifier is type_definition ;

function_call ::=

function_name [ ( actual_parameter_part ) ]

generate_statement ::=

generate_label :

generation_scheme generate
[ {block_declarative_item }
begin ]
{ architecture_statement }
end generate [ generate_label ] ;

generation_scheme ::=

for generate_parameter_specification
| if condition

generic_clause ::=

generic ( generic_list ) ;

generic_list ::=

generic_interface_list

generic_map_aspect ::=

generic map ( generic_association_list )

graphic_character ::=

basic_graphic_character | lower_case_letter | other_special_character

group_constituent ::=

name | character_literal

group_constituent_list ::=

group_constituent { , group_constituent }

group_declaration ::=

group identifier : group_template_name ( group_constituent_list ) ;

group_template_declaration ::=

group identifier is ( entity_class_entry_list ) ;

guarded_signal_specification ::=

guarded_signal_list : type_mark

identifier ::=

basic_identifier | extended_identifier

identifier_list ::=

identifier { , identifier }

if_statement ::=

[ if_label : ]

if condition then
sequence_of_statements
{ elsif condition then
sequence_of_statements }
[ else
sequence_of_statements ]
end if [ if_label ] ;

incomplete_type_declaration ::=

type identifier ;

index_constraint ::=

( discrete_range { , discrete_range } )

index_specification ::=

discrete_range
| static_expression

index_subtype_definition ::=

type_mark range <>

indexed_name ::=

prefix ( expression { , expression } )

instantiated_unit ::=

[ component ] component_name
| entity entity_name [ ( architecture_identifier ) ]
| configuration configuration_name

instantiation_list ::=

instantiation_label { , instantiation_label }
| others
| all

integer ::=

digit { [ underline ] digit }

integer_type_definition ::=

range_constraint

interface_constant_declaration ::=

[ constant ] identifier_list : [ in ] subtype_indication [ := static_expression ]

interface_declaration ::=

interface_constant_declaration
| interface_signal_declaration
| interface_variable_declaration
| interface_file_declaration
| interface_terminal_declaration
| interface_quantity_declaration

interface_element ::=

interface_declaration

interface_file_declaration ::=

file identifier_list : subtype_indication

interface_list ::=

interface_element { ; interface_element }

interface_quantity_declaration ::=

quantity identifier_list : [ in | out ] subtype_indication [ := static_expression ]

interface_signal_declaration ::=

[ signal ] identifier_list : [ mode ] subtype_indication [ bus ] [ := static_expression ]

interface_terminal_declaration ::=

terminal identifier_list : subnature_indication

interface_variable_declaration ::=

[ variable ] identifier_list : [ mode ] subtype_indication [ := static_expression ]

iteration_scheme ::=

while condition
| for loop_parameter_specification

label ::=

identifier

letter ::=

upper_case_letter | lower_case_letter

letter_or_digit ::=

letter | digit

library_clause ::=

library logical_name_list ;

library_unit ::=

primary_unit
| secondary_unit

literal ::=

numeric_literal
| enumeration_literal
| string_literal
| bit_string_literal
| null

logical_name ::=

identifier

logical_name_list ::=

logical_name { , logical_name }

logical_operator ::=

and | or | nand | nor | xor | xnor

loop_statement ::=

[ loop_label : ]

[ iteration_scheme ] loop
sequence_of_statements
end loop [ loop_label ] ;

miscellaneous_operator ::=

** | abs | not

mode ::=

in | out | inout | buffer | linkage

multiplying_operator ::=

* | / | mod | rem

name ::=

simple_name
| operator_symbol
| selected_name
| indexed_name
| slice_name
| attribute_name

nature_declaration ::=

nature identifier is nature_definition ;

nature_definition ::=

scalar_nature_definition
| composite_nature_definition

nature_element_declaration ::=

identifier_list : element_subnature_definition

nature_mark ::=

nature_name | subnature_name

next_statement ::=

[ label : ] next [ loop_label ] [ when condition ] ;

null_statement ::=

[ label : ] null ;

numeric_literal ::=

abstract_literal
| physical_literal

object_declaration ::=

constant_declaration
| signal_declaration
| variable_declaration
| file_declaration
| terminal_declaration
| quantity_declaration

operator_symbol ::=

string_literal

options ::=

[ guarded ] [ delay_mechanism ]

package_body ::=

package body package_simple_name is

package_body_declarative_part

end [ package body ] [ package_simple_name ] ;

package_body_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| shared_variable_declaration
| file_declaration
| alias_declaration
| use_clause
| group_template_declaration
| group_declaration

package_body_declarative_part ::=

{ package_body_declarative_item }

package_declaration ::=

package identifier is

package_declarative_part

end [ package ] [ package_simple_name ] ;

package_declarative_item ::=

subprogram_declaration
| type_declaration
| subtype_declaration
| constant_declaration
| signal_declaration
| shared_variable_declaration
| file_declaration
| alias_declaration
| component_declaration
| attribute_declaration
| attribute_specification
| disconnection_specification
| use_clause
| group_template_declaration
| group_declaration
| nature_declaration
| subnature_declaration
| terminal_declaration

package_declarative_part ::=

{ package_declarative_item }

parameter_specification ::=

identifier in discrete_range

physical_literal ::=

[ abstract_literal ] unit_name

physical_type_definition ::=

range_constraint

units
primary_unit_declaration
{ secondary_unit_declaration }
end units [ physical_type_simple_name ]

port_clause ::=

port ( port_list ) ;

port_list ::=

port_interface_list

port_map_aspect ::=

port map ( port_association_list )

prefix ::=

name
| function_call

primary ::=

name
| literal
| aggregate
| function_call
| qualified_expression
| type_conversion
| allocator
| ( expression )

primary_unit ::=

entity_declaration
| configuration_declaration
| package_declaration

primary_unit_declaration ::=

identifier ;

procedural_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| variable_declaration
| alias_declaration
| attribute_declaration
| attribute_specification
| use_clause
| group_template_declaration
| group_declaration

procedural_declarative_part ::=

{ procedural_declarative_item }

procedural_statement_part ::=

{ sequential_statement }

procedure_call ::=

procedure_name [ ( actual_parameter_part ) ]

procedure_call_statement ::=

[ label : ] procedure_call ;

process_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| variable_declaration
| file_declaration
| alias_declaration
| attribute_declaration
| attribute_specification
| use_clause
| group_template_declaration
| group_declaration

process_declarative_part ::=

{ process_declarative_item }

process_statement ::=

[ process_label : ]

[ postponed ] process [ ( sensitivity_list ) ] [ is ]
process_declarative_part
begin
process_statement_part
end [ postponed ] process [ process_label ] ;

process_statement_part ::=

{ sequential_statement }

qualified_expression ::=

type_mark ' ( expression )
| type_mark ' aggregate

quantity_declaration ::=

free_quantity_declaration
| branch_quantity_declaration
| source_quantity_declaration

quantity_list ::=

quantity_name { , quantity_name }
| others
| all

quantity_specification ::=

quantity_list : type_mark

range ::=

range_attribute_name
| simple_expression direction simple_expression

range_constraint ::=

range range

record_nature_definition ::=

record

nature_element_declaration
{ nature_element_declaration }

end record [ record_nature_simple_name ]

record_type_definition ::=

record

element_declaration
{ element_declaration }

end record [ record_type_simple_name ]

relation ::=

shift_expression [ relational_operator shift_expression ]

relational_operator ::=

= | /= | < | <= | > | >=

report_statement ::=

[ label : ]

report expression
[ severity expression ] ;

return_statement ::=

[ label : ] return [ expression ] ;

scalar_nature_definition ::=

type_mark across

type_mark through

identifier reference

scalar_type_definition ::=

enumeration_type_definition
| integer_type_definition
| floating_type_definition
| physical_type_definition

secondary_unit ::=

architecture_body
| package_body

secondary_unit_declaration ::=

identifier = physical_literal ;

selected_name ::=

prefix . suffix

selected_signal_assignment ::=

with expression select

target <= options selected_waveforms ;

selected_waveforms ::=

{ waveform when choices , }
waveform when choices

sensitivity_clause ::=

on sensitivity_list

sensitivity_list ::=

signal_name { , signal_name }

sequence_of_statements ::=

{ sequential_statement }

sequential_statement ::=

wait_statement
| assertion_statement
| report_statement
| signal_assignment_statement
| variable_assignment_statement
| procedure_call_statement
| if_statement
| case_statement
| loop_statement
| next_statement
| exit_statement
| return_statement
| null_statement
| break_statement

shift_expression ::=

simple_expression [ shift_operator simple_expression ]

shift_operator ::=

sll | srl | sla | sra | rol | ror

sign ::=

+ | -

signal_assignment_statement ::=

[ label : ] target <= [ delay_mechanism ] waveform ;

signal_declaration ::=

signal identifier_list : subtype_indication [ signal_kind ] [ := expression ] ;

signal_kind ::=

register | bus

signal_list ::=

signal_name { , signal_name }
| others
| all

signature ::=

[ [ type_mark { , type_mark } ] [ return type_mark ] ]

simple_expression ::=

[ sign ] term { adding_operator term }

simple_name ::=

identifier

simple_simultaneous_statement ::=

[ label : ] simple_expression == simple_expression [ tolerance_aspect ] ;

simultaneous_alternative ::=

when choices =>

simultaneous_statement_part

simultaneous_case_statement ::=

[ case_label : ]

case expression use
simultaneous_alternative
{ simultaneous_alternative }
end case [ case_label ] ;

simultaneous_if_statement ::=

[ if_label : ]

if condition use
simultaneous_statement_part
{ elsif condition then
simultaneous_statement_part }
[ else
simultaneous_statement_part ]
end use [ if_label ] ;

simultaneous_null_statement ::=

[ label : ] null ;

simultaneous_procedural_statement ::=

[ procedural_label : ]

procedural [ is ]
procedural_declarative_part
begin
procedural_statement_part
end procedural [ procedural_label ] ;

simultaneous_statement ::=

simple_simultaneous_statement
| simultaneous_if_statement
| simultaneous_case_statement
| simultaneous_procedural_statement
| simultaneous_null_statement

simultaneous_statement_part ::=

{ simultaneous_statement }

slice_name ::=

prefix ( discrete_range )

source_aspect ::=

spectrum magnitude_simple_expression , phase_simple_expression
| noise power_simple_expression

source_quantity_declaration ::=

quantity identifier_list : subtype_indication source_aspect ;

step_limit_specification ::=

limit quantity_specification with real_expression ;

subnature_declaration ::=

subnature identifier is subnature_indication ;

subnature_indication ::=

nature_mark [ index_constraint ] [ tolerance string_expression across string_expression through ]

string_literal ::=

" { graphic_character } "

subprogram_body ::=

subprogram_specification is

subprogram_declarative_part

begin

subprogram_statement_part

end [ subprogram_kind ] [ designator ] ;

subprogram_declaration ::=

subprogram_specification ;

subprogram_declarative_item ::=

subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| variable_declaration
| file_declaration
| alias_declaration
| attribute_declaration
| attribute_specification
| use_clause
| group_template_declaration
| group_declaration

subprogram_declarative_part ::=

{ subprogram_declarative_item }

subprogram_kind ::=

procedure | function

subprogram_specification ::=

procedure designator [ ( formal_parameter_list ) ]
| [ pure | impure ] function designator [ ( formal_parameter_list ) ]

return type_mark

subprogram_statement_part ::=

{ sequential_statement }

subtype_declaration ::=

subtype identifier is subtype_indication ;

subtype_indication ::=

[ resolution_function_name ] type_mark [ constraint ] [ tolerance_aspect ]

suffix ::=

simple_name
| character_literal
| operator_symbol
| all

target ::=

name
| aggregate

term ::=

factor { multiplying_operator factor }

terminal_aspect ::=

plus_terminal_name [ to minus_terminal_name ]

terminal_declaration ::=

terminal identifier_list : subnature_indication ;

through_aspect ::=

identifier_list [ tolerance_aspect ] [ := expression ] through

timeout_clause ::=

for time_or_real_expression

tolerance_aspect ::=

tolerance string_expression

type_conversion ::=

type_mark ( expression )

type_declaration ::=

full_type_declaration
| incomplete_type_declaration

type_definition ::=

scalar_type_definition
| composite_type_definition
| access_type_definition
| file_type_definition

type_mark ::=

type_name
| subtype_name

unconstrained_array_definition ::=

array ( index_subtype_definition { , index_subtype_definition } )

of element_subtype_indication

unconstrained_nature_definition ::=

array ( index_subtype_definition { , index_subtype_definition } )

of subnature_indication

use_clause ::=

use selected_name { , selected_name } ;

variable_assignment_statement ::=

[ label : ] target := expression ;

variable_declaration ::=

[ shared ] variable identifier_list : subtype_indication [ := expression ] ;

wait_statement ::=

[ label : ] wait [ sensitivity_clause ] [ condition_clause ] [ timeout_clause ] ;

waveform ::=

waveform_element { , waveform_element }
unaffected

waveform_element ::=

value_expression [ after time_expression ]
| null [ after time_expression ]

Reserved Words

abs, access, across, after, alias, all, and, architecture, array, assert, attribute,
begin, block, body, break, buffer, bus,
case, component, configuration, constant,
disconnect, downto,
else, elsif, end, entity, exit,
file, for, function,
generate, generic, group, guarded,
if, impure, in, inertial, inout, is,
label, library, limit, linkage, literal, loop,
map, mod,
nand, nature, new, next, noise, nor, not, null,
of, on, open, or, others, out,
package, port, postponed, procedural, procedure, process, pure,
quantity,
range, record, reference, register, reject, rem, report, return, rol, ror,
select, severity, shared, signal, sla, sll, spectrum, sra, srl, subnature, subtype,
terminal, then, through, to, tolerance, transport, type,
unaffected, units, until, use,
variable,
wait, when, while, with,
xnor, xor

Predefined Attributes

T'BASE
T'LEFT
T'RIGHT
T'HIGH
T'LOW
T'ASCENDING
T'IMAGE(X)
T'VALUE(X)
T'POS(X)
T'VAL(X)
T'SUCC(X)
T'PRED(X)
T'LEFTOF(X)
T'RIGHTOF(X)
T'REFERENCE
T'CONTRIBUTION
T'TOLERANCE

A'LEFT[(N)]
A'RIGHT[(N)]
A'HIGH[(N)]
A'LOW[(N)]
A'RANGE[(N)]
A'REVERSE_RANGE[(N)]
A'LENGTH[(N)]
A'ASCENDING[(N)]

S'DELAYED[(T)]
S'STABLE[(T)]
S'QUIET[(T)]
S'TRANSACTION
S'EVENT
S'ACTIVE
S'LAST_EVENT
S'LAST_ACTIVE
S'LAST_VALUE
S'DRIVING
S'DRIVING_VALUE
S'RAMP[(TRISE [,TFALL])]
S'SLEW[(RISING_SLOPE [,FALLING_SLOPE])]

E'SIMPLE_NAME
E'INSTANCE_NAME
E'PATH_NAME

N'ACROSS
N'THROUGH

Q'TOLERANCE
Q'DOT
Q'INTEG
Q'DELAYED[(T)]
Q'ABOVE(E)
Q'ZOH(T [,INITIAL_DELAY])
Q'LTF(NUM,DEN)
Q'ZTF(NUM,DEN,T [,INITIAL_DELAY])
Q'SLEW[(MAX_RISING_SLOPE [,MAX_FALLING_SLOPE])]