Purnank H.G. VHDL-AMS Syntax (IEEE Std 1076.1)
UpEMACSEDA ToolsVHDL Syntax (IEEE Std 1076-1993)VHDL Syntax (IEEE Std 1076-1993)VHDL-AMS Syntax (IEEE Std 1076.1)

 

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 begin 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

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 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_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_statement_alternative ::=
when choices =>

character_literal ::=
' graphic_character '

choice ::=
simple_expression
| discrete_range
| element_simple_name
| others

choices ::=
choice { | choice }

component_configuration ::=
for component_specification end for ;

component_declaration ::=
component identifier [ is ] end component [ component_simple_name ] ;

component_instantiation_statement ::=
instantiation_label :

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 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 [ begin 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 ::=
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 : ]

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 : ]

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

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 : ]

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 end record [ record_nature_simple_name ]

record_type_definition ::=
record end record [ record_type_simple_name ]

relation ::=
shift_expression [ relational_operator shift_expression ]

relational_operator ::=
= | /= | < | <= | > | >=

report_statement ::=
[ label : ]

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

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_case_statement ::=
[ case_label : ]

simultaneous_if_statement ::=
[ if_label : ]

simultaneous_null_statement ::=
[ label : ] null ;

simultaneous_procedural_statement ::=
[ 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 begin 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 ) ]

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 } )

unconstrained_nature_definition ::=
array ( index_subtype_definition { , index_subtype_definition } )

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 = scalar type, subtype or terminal, A = array type, S = signal, E = named entity, N = nature, Q = quantity)
    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])]


Site developed and maintianed by purnank <AT> sancharnet.in Sign My GuestBook.
Hosted by www.Geocities.ws

1