====== VHDL Glossary ======
//This part of the FAQ is reprinted from IEEE Std 1076-1993 IEEE Standard VHDL Language Reference Manual, Copyright © 1994 by the Institute of Electrical and Electronics Engineers, Inc. The IEEE disclaims any responsibility or liability resulting from the placement and use in this product. Information is reprinted with the permission of the IEEE. Further distribution is not permitted without consent of the IEEE Standards Department.//

This glossary contains brief, informal descriptions for a number of terms and phrases used to define this language. The complete, formal definition of each term or phrase is provided in the main body of the standard.

For each entry, the relevant clause numbers in the text are given. Some descriptions refer to multiple clauses in which the single concept is discussed; for these, the clause number containing the definition of the concept is given in italics. Other descriptions contain multiple clause numbers when they refer to multiple concepts; for these, none of the clause numbers are italicized.

===== A =====
==== abstract literal ====
A [[start#literal]] of the [[start#universal_real]] abstract [[start#type]] or the [[start#universal_integer]] abstract type. (§13.2, §13.4)

==== access type ====
A [[start#type]] that provides access to an [[start#object]] of a given [[start#type]]. Access to such an object is achieved by an [[start#access value]] returned by an [[start#allocator]]; the access value is said to [[start#designate]] the object. (§3, §13.3)

==== access mode ====
The mode in which a file [[start#object]] is opened, which can be either read-only or write-only. The access mode depends on the value supplied to the Open_Kind [[start#parameter]]. (§3.4.1, §14.3).

==== access value ====
A value of an [[start#access type]]. This value is returned by an [[start#allocator]] and [[start#designate]]s an [[start#object]] (which must be a [[start#variable]]) of a given [[start#type]]. A null access value designates no object. An access value can only designate an object created by an allocator; it cannot designate an object declared by an object [[start#declaration]]. (§3, 3.3)

==== active driver ====
A [[start#driver]] that acquires a new value during a [[start#simulation cycle]] regardless of whether the new value is different from the previous value. (§12.6.2, §12.6.4)

==== actual ====
An [[start#expression]], a [[start#port]], a [[start#signal]], or a [[start#variable]] associated with a [[start#formal]] port, formal parameter, or formal generic. (§1.1.1.1, §1.1.1.2, §3.2.1.1, §4.3.1.2, §4.3.2.2, §5.2.1, §5.2.1.2)

==== aggregate ====
  - The kind of [[start#expression]], denoting a value of a [[start#composite type]]. The value is specified by giving the value of each of the elements of the composite type. Either a [[start#positional association]] or a [[start#named association]] may be used to indicate which value is associated with which element.
  - A kind of target of a [[start#variable]] assignment statement or [[start#signal]] assignment statement assigning a composite value. The target is then said to //be in the form of an aggregate//. (§7.3.1, §7.3.2, §7.3.4, 7.3.5, §7.5.2)

==== alias ====
An alternate [[start#name]] for a [[start#named entity]]. (§4.3.3)

==== allocator ====
An operation used to create [[start#anonymous]], [[start#variable]] objects accessible by means of [[start#access value]]s. (§3.3, §7.3.6)

==== analysis ====
The syntactic and semantic analysis of source code in a VHDL [[start#design file]] and the insertion of intermediate form representations of [[start#design unit]]s into a [[start#design library]]. (§1 1.1, §11.2, §11.4)

==== anonymous ====
The undefined [[start#simple name]] of an item, which is created implicitly. The base [[start#type]] of a [[start#numeric type]] or an [[start#array type]] is anonymous; similarly, the [[start#object]] denoted by an [[start#access value]] is anonymous. (§4.1)

==== appropriate ====
A prefix is said to be appropriate for a [[start#type]] if the type of the prefix is the type considered, or if the type of the prefix is an [[start#access type]] whose [[start#designated type]] is the type considered. (§6.1)

==== architecture body ====
A body associated with an [[start#entity declaration]] to describe the internal organization or operation of a [[start#design entity]]. An architecture body is used to describe the behavior, data flow, or structure of a design entity. (§1, §1.2)

==== array object ====
An [[start#object]] of an [[start#array type]]. (§3)

==== array type ====
A [[start#type]], the value of which consists of elements that are all of the same [[start#subtype]] (and hence, of the same type). Each element is uniquely distinguished by an index (for a one-dimensional array) or by a sequence of indexes (for a multidimensional array). Each index must be a value of a [[start#discrete type]] and must lie in the correct [[start#index range]]. (§3.2.1)

==== ascending range ====
A [[start#range]] L **to** R. (§3.1)

==== ASCII ====
The American Standard Code for Information Interchange. The package Standard contains the definition of the [[start#type]] Character, the first 128 values of which represent the ASCII character set. (§3.1.1, §14.2)

==== assertion violation ====
A violation that occurs when the condition of an assertion statement evaluates to false. (§8.2)

==== associated driver ====
The single [[start#driver]] for a [[start#signal]] in the (explicit or equivalent) process statement containing the signal assignment statement. (§12.6.1)

==== associated in whole ====
When a single [[start#association element]] of a composite [[start#formal]] supplies the association for the entire formal. (§4.3.2.2)

==== associated individually ====
A property of a [[start#formal]] port, generic, or parameter of a [[start#composite type]] with respect to some [[start#association list]]. A composite formal whose association is defined by multiple [[start#association element]]s in a single association list is said to be //associated individually// in that list. The formats of such association elements must denote non-overlapping [[start#subelement]]s or [[start#slice]]s of the formal. (§4.3.2.2)

==== association element ====
An element that associates an [[start#actual]] or local with a local or [[start#formal]]. (§4.3.2.2)

==== association list ====
A list that establishes correspondences between [[start#formal]] or [[start#local port]] or [[start#parameter]] [[start#name]]s and local or [[start#actual]] names or [[start#expression]]s. (§4.3.2.2)

==== attribute ====
A definition of some characteristic of a [[start#named entity]]. Some attributes are predefined for [[start#type]]s, [[start#range]]s, values, [[start#signal]]s, and functions. The remaining attributes are user defined and are always [[start#constant]]s. (§4.4)

===== B =====
==== base specifier ====
A lexical element that indicates whether a [[start#bit string literal]] is to be interpreted as a binary, octal, or hexadecimal value. (§13.7)

==== base type ====
The [[start#type]] from which a subtype defines a subset of possible values, otherwise known as a [[start#constraint]]. This subset is not required to be proper. The base type of a type is the type itself. The base type of a subtype is found by recursively examining the type mark in the subtype indication defining the subtype. If the type mark denotes a type, that type is the base type of the subtype; otherwise, the type mark is a subtype, and this procedure is repeated on that subtype. (§3) //See also// [[start#subtype]].

==== based literal ====
An [[start#abstract literal]] expressed in a form that specifies the base explicitly. The base is restricted to the range 2 to 16. (§13.4.2)

==== basic operation ====
An operation that is inherent in one of the following:
  - An assignment (in an assignment statement or initialization);
  - An [[start#allocator]];
  - A [[start#selected name]], an indexed [[start#name]]. or a [[start#slice]] name;
  - A qualification (in a qualified [[start#expression]]), an explicit [[start#type conversion]], a [[start#formal]] or [[start#actual]] [[start#designator]] in the form of a type conversion, or an implicit type conversion of a value of [[start#type]] [[start#universal_integer]] or [[start#universal_real]] to the corresponding value of another [[start#numeric type]]; or
  - A [[start#numeric literal]] (for a universal type), the [[start#literal]] null (for an [[start#access type]]), a [[start#string literal]], a [[start#bit string literal]], an [[start#aggregate]], or a predefined [[start#attribute]]. (§3)

==== basic signal ====
A [[start#signal]] that determines the [[start#driving value]]s for all other signals. A basic signal is
  * Either a scalar signal or a [[start#resolved signal]];
  * Not a [[start#subelement]] of a resolved signal;
  * Not an [[start#implicit signal]] of the form [[start#attribute|S'Stable(T), S'Quiet(T), or S'Transaction]]; and
  * Not an implicit signal [[start#GUARD]]. (§12.6.2)

==== belong (to a range) ====
A property of a value with respect to some [[start#range]]. The value V is said to //belong to a range// if the relations ( [[start#lower bound]] <= V) and (V <= [[start#upper bound]]) are both true, where lower bound and upper bound are the lower and upper bounds, respectively, of the range. (§3.1, §3.2.1)

==== belong (to a subtype) ====
A property of a value with respect to some [[start#subtype]]. A value is said to //belong to a subtype// of a given [[start#type]] if it belongs to the type and satisfies the applicable [[start#constraint]]. (§3, §3.2.1)

==== binding ====
The process of associating a [[start#design entity]] and, optionally, an architecture with an [[start#instance]] of a component. A binding can be specified in an explicit or a default binding indication. (§1.3, §5.2.1, §5.2.2, §12.3.2.2, §12.4.3)

==== bit string literal ====
A [[start#literal]] formed by a sequence of [[start#extended digit]]s enclosed between two quotation (") characters and preceded by a [[start#base specifier]]. The [[start#type]] of a bit string literal is determined from the context. (§7.3.1, §13.7)

==== block ====
The representation of a portion of the hierarchy of a design. A block is either an [[start#external block]] or an [[start#internal block]]. (§1, §1.1.1.1, §1.1.1.2, §1.2.1, §1.3, §1.3.1, §1.3.2)

==== bound ====
A label that is identified in the instantiation list of a [[start#configuration]] [[start#specification]]. (§5.2)

==== box ====
The symbol <> in an [[start#index subtype]] definition, which stands for an undefined [[start#range]]. Different [[start#object]]s of the [[start#type]] need not have the same bounds and direction. (§3.2.1)

==== bus ====
One kind of [[start#guarded signal]]. A bus floats to a user-specified value when all of its [[start#driver]]s are turned off. (§4.3.1.2, §4.3.2)

===== C =====
==== character literal ====
A [[start#literal]] of the [[start#character type]]. Character literals are formed by enclosing one of the graphic characters (including the space and nonbreaking space characters) between two apostrophe (') characters. (§13.2, §13.5)

==== character type ====
An [[start#enumeration type]] with at least one [[start#character literal]] among its [[start#enumeration literal]]s. (§3.1.1, §3.1.1.1)

==== closely related types ====
Two [[start#type]] marks that denote the same type or two [[start#numeric type]]s. Two [[start#array type]]s may also be closely related if they have the same dimensionality, if their index types at each position are closely related, and if the array types have the same element types. Explicit [[start#type conversion]] is only allowed between closely related types. (§7.3.5)

==== complete ====
A loop that has finished executing. Similarly, an iteration scheme of a loop is complete when the condition of a while iteration scheme is FALSE or all of the values of the [[start#discrete range]] of a for iteration scheme have been assigned to the iteration parameter. (§8.9)

==== complete context ====
A [[start#declaration]], a [[start#specification]], or a statement; complete contexts are used in overload resolution. (§10.5)

==== composite type ====
A [[start#type]] whose values have elements. There are two classes of composite types: [[start#array type]]s and [[start#record type]]s. (§3, §3.2)

==== concurrent statement ====
A statement that [[start#execute]]s asynchronously, with no defined relative order. Concurrent statements are used for dataflow and structural descriptions. (§9)

==== configuration ====
A construct that defines how component [[start#instance]]s in a given [[start#block]] are [[start#bound]] to design entities in order to describe how design entities are put together to form a complete design. (§1, §1.3. 5.2)

==== conform ====
Two [[start#subprogram specification]]s, are said to conform if, apart from certain allowed minor variations, both [[start#specification]]s are formed by the same sequence of lexical elements, and corresponding lexical elements are given the same meaning by the visibility rules. Conformance is defined similarly for [[start#deferred constant]] [[start#declaration]]s. (§2.7)

==== connected ====
A [[start#formal]] [[start#port]] associated with an [[start#actual]] port or [[start#signal]]. A formal port associated with the reserved word **open** is said to be //unconnected//. (§1.1.1.2)

==== constant ====
An [[start#object]] whose value may not be changed. Constants may be //explicitly// declared, [[start#subelement]]s of [[start#explicitly declared constant]]s, or interface constants. Constants declared in packages may also be [[start#deferred constant]]s. (§4.3.1.1)

==== constraint ====
A subset of the values of a [[start#type]]. The set of possible values for an [[start#object]] of a given type that can be subjected to a condition called a constraint. A value is said to [[start#satisfy]] the constraint if it satisfies the corresponding condition. There are [[start#index constraint]]s, [[start#range constraint]]s, and size constraints. (§3)

==== conversion function ====
A function used to convert values flowing through associations. For interface [[start#object]]s of [[start#mode]] **in**, conversion functions are allowed only on [[start#actual]]s. For interface objects of mode **out** or **buffer**, conversion functions are allowed only on [[start#formal]]s. For interface objects of mode **inout** or **linkage**, conversion functions are allowed on both formals and actuals. Conversion functions have a single [[start#parameter]]. A conversion function associated with an actual accepts the [[start#type]] of the actual and returns the type of the formal. A conversion function associated with a formal accepts the type of the formal and returns the type of the actual. (§4.3.2.2)

==== convertible ====
A property of an operand with respect to some [[start#type]]. An operand is convertible to some type if there exists an implicit conversion to that type. (§7.3.5)

==== current value ====
The value component of the single [[start#transaction]] of a [[start#driver]] whose time component is not greater than the current simulation time. (§12.6. 12.6.1, §12.6.2, §12.6.3)

===== D =====
==== decimal literal ====
An [[start#abstract literal]] that is expressed in decimal notation. The base of the [[start#literal]] is implicitly 10. The literal may optionally contain an exponent or a decimal point and fractional part. (§13.4.1)

==== declaration ====
A construct that defines a declared entity and associates an identifier (or some other notation) with it. This association is in effect within a region of text that is called the [[start#scope]] of the declaration. Within the scope of a declaration, there are places where it is possible to use the identifier to refer to the associated declared entity; at such places, the identifier is said to be the [[start#simple name]] of the [[start#named entity]]. The simple name is said to [[start#denote]] the associated named entity. (§4)

==== declarative part ====
A syntactic component of certain [[start#declaration]]s or statements (such as [[start#entity declaration]]s, [[start#architecture body|architecture bodies]], and [[start#block]] statements). The [[start#declarative part]] defines the lexical area (usually introduced by a keyword such as **is** and terminated with another keyword such as **begin**) within which declarations may occur. (§1.1.2, §1.2.1, §1.3, §2.6, §9.1, §9.2, §9.6.1, §9.6.2)

==== declarative region ====
A semantic component of certain [[start#declaration]]s or statements. A declarative region may include disjoint parts, such as the declarative region of an [[start#entity declaration]], which [[start#extend]]s to the end of any [[start#architecture body]] for that entity. (§10.1)

==== decorate ====
To associate a user-defined [[start#attribute]] with a [[start#named entity]] and to {define} the value of that attribute. (§5.1)

==== default expression ====
A default value that is used for a [[start#formal]] generic, port, or parameter if the interface [[start#object]] is unassociated. A default expression is also used to provide an initial value for [[start#signal]]s and their [[start#driver]]s. (§4.3.1.2, §4.3.2.2)

==== deferred constant ====
A [[start#constant]] that is declared without an assignment symbol <nowiki>(:=)</nowiki> and [[start#expression]] in a package [[start#declaration]]. A corresponding [[start#full declaration]] of the constant must exist in the package body to define the value of the constant. (§4.3.1.1)

==== delta cycle ====
A [[start#simulation cycle]] in which the simulation time at the beginning of the cycle is the same as at the end of the cycle. That is, simulation time is not advanced in a delta cycle. Only nonpostponed processes can be executed during a delta cycle. (§12.6.4)

==== denote ====
A property of the identifier given in a [[start#declaration]]. Where the declaration is [[start#visible]], the identifier given in the declaration is said to //denote// the [[start#named entity]] declared in the declaration. (§4)

==== depend (on a library unit) ====
A [[start#design unit]] that explicitly or implicitly mentions other [[start#library unit]]s in a use clause. These dependencies affect the allowed order of [[start#analysis]] of design units. (§11.4)

==== depend (on a signal value) ====
A property of an [[start#implicit signal]] with respect to some other [[start#signal]]. The [[start#current value]] of an implicit signal R is said to //depend// on the current value of another signal S if R denotes an implicit signal S'Stable(T), S'Quiet(T), or S'Transaction, or if R denotes an implicit [[start#GUARD]] signal and S is any other implicit signal named within the [[start#guard expression]] that defines the current value of R. (§12.6.3)

==== descending range ====
A [[start#range]] L **downto** R. (§3.1)

==== design entity ====
An [[start#entity declaration]] together with an associated [[start#architecture body]]. Different design entities may share the same entity declaration, thus describing different components with the same interface or different views of the same component. (§1)

==== design file ====
One or more [[start#design unit]]s in sequence. (§1.1)

==== design hierarchy ====
The complete representation of a design that results from the successive decomposition of a [[start#design entity]] into subcomponents and [[start#binding]] of those components to other design entities that may be decomposed in a similar manner. (§1)

==== design library ====
A host-dependent storage facility for intermediate-form representations of analyzed [[start#design unit]]s. (§11.2)

==== design unit ====
A construct that can be independently analyzed and stored in a [[start#design library]]. A design unit may be an [[start#entity declaration]], an [[start#architecture body]], a [[start#configuration declaration]], a package declaration, or a package body declaration. (§11.1)

==== designate ====
A property of [[start#access value]]s that relates the value to some [[start#object]] when the access value is nonnull. A nonnull access value is said to //designate// an object. (§3.3)

==== designated subtype ====
For an [[start#access type]], the [[start#subtype]] defined by the subtype indication of the access type definition. (§3.3)

==== designated type ====
For an [[start#access type]], the base [[start#type]] of the [[start#subtype]] defined by the subtype indication of the access type definition. (§3.3)

==== designator ====
  - Syntax that forms part of an [[start#association element]]. A formal designator specifies which [[start#formal]] parameter, port, or generic (or which [[start#subelement]] or [[start#slice]] of a [[start#parameter]], [[start#port]], or [[start#generic]]) is to be associated with an [[start#actual]] by the given association element. An actual designator specifies which actual expression, signal, or variable is to be associated with a formal (or subelement or subelements of a formal). An actual designator may also specify that the formal in the given association element is to be left unassociated (with an actual designator of **open**). (§4.3.2.2)
  - An identifier, [[start#character literal]], or operator symbol that defines an [[start#alias]] for some other [[start#name]]. (§4.3.3)
  - A [[start#simple name]] that denotes a predefined or user-defined [[start#attribute]] in an attribute name, or a user-defined attribute in an attribute [[start#specification]]. (§5.1, §6.6)
  - An simple name, character literal, or operator symbol, and possibly a signature, that denotes a [[start#named entity]] in the entity name list of an attribute specification. (§5.1)
  - An identifier or operator symbol that defines the name of a subprogram. (§2.1)

==== directly visible ====
A visible [[start#declaration]] that is not visible by selection. A declaration is directly visible within its [[start#immediate scope]], excluding any places where the declaration is [[start#hidden]]. A declaration occurring [[start#immediately within]] the visible part of a package can be made directly visible by means of a use clause. (§10.3, 10.4). //See also// [[start#visible]].

==== discrete array ====
A one-dimensional array whose elements are of a [[start#discrete type]]. (§7.2.3)

==== discrete range ====
A [[start#range]] whose [[start#bound]]s are of a [[start#discrete type]]. (§3.2.1, §3.2.1.1)

==== discrete type ====
An [[start#enumeration type]] or an [[start#integer type]]. Each value of a discrete type has a position number that is an integer value. Indexing and iteration rules use values of discrete types. (§3.1)

==== driver ====
A container for a [[start#projected output waveform]] of a [[start#signal]]. The value of the signal is a function of the [[start#current value]]s of its drivers. Each process that assigns to a given signal implicitly contains a driver for that signal. A signal assignment statement affects only the [[start#associated driver]](s). (§12.4.4, §12.6.1, §12.6.2, §12.6.3)

==== driving value ====
The value a [[start#signal]] provides as a [[start#source]] of other signals. (§12.6.2)

===== E =====
==== effective value ====
The value obtained by evaluating a reference to the [[start#signal]] within an [[start#expression]]. (§12.6.2)

==== elaboration ====
The process by which a [[start#declaration]] achieves its effect. Prior to the completion of its elaboration (including before the elaboration), a declaration is not yet elaborated. (§12)

==== element ====
A constituent of a [[start#composite type]]. (§3) //See also// [[start#subelement]].

==== entity declaration ====
A definition of the interface between a given [[start#design entity]] and the environment in which it is used. It may also specify [[start#declaration]]s and statements that are part of the design entity. A given entity declaration may be shared by many design entities, each of which has a different architecture. Thus, an entity declaration can potentially represent a class of design entities, each with the same interface. (§1, §1.1)

==== enumeration literal ====
A [[start#literal]] of an [[start#enumeration type]]. An enumeration literal may be either an identifier or a [[start#character literal]]. (§5.1.1, §7.3.1)

==== enumeration type ====
A [[start#type]] whose values are defined by listing (enumerating) them. The values of the type are represented by [[start#enumeration literal]]s. (§3.1, §3.1.1)

==== error ====
A condition that makes the source description illegal. If an error is detected at the time of [[start#analysis]] of a [[start#design unit]], it prevents the creation of a [[start#library unit]] for the given design unit. A run-time error causes simulation to terminate. (§11.4)

==== erroneous ====
An [[start#error]] condition that cannot always be detected. (§2.1.1.1, §2.2)

==== event ====
A change in the [[start#current value]] of a [[start#signal]], which occurs when the signal is updated with its [[start#effective value]]. (§12.6.2)

==== execute ====
  - When first the [[start#design hierarchy]] of a [[start#model]] is elaborated, then its [[start#net]]s are initialized, and finally simulation proceeds with repetitive execution of the [[start#simulation cycle]], during which processes are executed and nets are updated.
  - When a process performs the actions specified by the algorithm described in its statement part. (§12, 12.6)

==== expanded name ====
A selected name (in the syntactic sense) that denotes one or all of the primary units in a [[start#library]] or any [[start#named entity]] within a primary unit. (§6.3, §8.1) //See also// [[start#selected name]].

==== explicit ancestor ====
The parent of the [[start#implicit signal]] that is defined by the predefined [[start#attribute]]s 'DELAYED, 'QUIET, 'STABLE, or 'TRANSACTION. It is determined using the prefix of the attribute. If the prefix denotes an [[start#explicit signal]] or (or [[start#member]] thereof), then that is the explicit ancestor of the implicit signal. If the prefix is one of the implicit signals defined by the predefined attributes 'DELAYED, 'QUIET, 'STABLE, or 'TRANSACTION, this rule is applied recursively. If the prefix is an implicit signal [[start#GUARD]], the [[start#signal]] has no explicit ancestor. (§2.2)

==== explicit signal ====
A [[start#signal]] defined by the predefined [[start#attribute]]s 'DELAYED, 'QUIET, 'STABLE, or 'TRANSACTION. (§2.2)

==== explicitly declared constant ====
A [[start#constant]] of a specified [[start#type]] that is declared by a constant [[start#declaration]]. (§4.3.1.1)

==== explicitly declared object ====
An [[start#object]] of a specified [[start#type]] that is declared by an object [[start#declaration]]. An object declaration is called a [[start#single-object declaration]] if its identifier list has a single identifier; it is called a //multiple-object declaration// if the identifier list has two or more identifiers. (§4.3, §4.3.1) //See also// [[start#implicitly declared object]].

==== expression ====
A formula that defines the computation of a value. (§7.1)

==== extend ====
A property of source text forming a [[start#declarative region]] with disjoint parts. In a declarative region with disjoint parts, if a portion of text is said to //extend// from some specific point of a declarative region to the end of the region, then this portion is the corresponding subset of the declarative region (and does not include intermediate declarative items between an interface [[start#declaration]] and a corresponding body declaration). (§10.1)

==== extended digit ====
A lexical element that is either a digit or a letter. (§13.4.2)

==== external block ====
A top-level [[start#design entity]] that resides in a [[start#library]] and may be used as a component in other designs. (§1)

===== F =====
==== file type ====
A [[start#type]] that provides access to [[start#object]]s containing a sequence of values of a given type. File types are typically used to access files in the host system environment. The value of a file object is the sequence of values contained in the host system file. (§3, §3.4)

==== floating point types ====
A discrete [[start#scalar type]] whose values approximate real numbers. The representation of a floating point [[start#type]] includes a minimum of six decimal digits of precision. (§3.1, §3.1.4)

==== foreign subprogram ====
A subprogram that is decorated with the [[start#attribute]] 'FOREIGN, defined in package STANDARD. The STRING value of the attribute may specify implementation-dependent information about the foreign subprogram. Foreign subprograms may have non-VHDL implementations. An implementation may place restrictions on the allowable [[start#mode]]s, classes, and [[start#type]]s of the [[start#formal]] parameters to a foreign subprogram, such as constraints on the number and allowable order of the [[start#parameter]]s. (§2.2)

==== formal ====
A formal [[start#port]] or formal [[start#generic]] of a [[start#design entity]], a [[start#block]] statement, or a formal [[start#parameter]] of a subprogram. (§2.1.1, §4.3.2.2, §5.2.1.2, §9.1)

==== full declaration ====
A [[start#constant]] [[start#declaration]] occurring in a package body with the same identifier as that of a [[start#deferred constant]] declaration in the corresponding package declaration. A full [[start#type]] declaration is a type declaration corresponding to an [[start#incomplete type declaration]]. (§2.6)

==== fully bound ====
A [[start#binding]] indication for the component [[start#instance]] implies an entity interface and an architecture. (§5.2.1.1)

===== G =====
==== generate parameter ====
A [[start#constant]] [[start#object]] whose [[start#type]] is the [[start#base type]] of the [[start#discrete range]] of a generate parameter [[start#specification]]. A generate parameter is declared by a generate statement. (§9.7)

==== generic ====
An interface [[start#constant]] declared in the [[start#block]] header of a block statement, a component [[start#declaration]], or an [[start#entity declaration]]. Generics provide a channel for [[start#static]] information to be communicated to a block from its environment. Unlike constants, however, the value of a generic can be supplied externally, either in a component instantiation statement or in a [[start#configuration specification]]. (§1.1.1.1)

==== generic interface list ====
A list that defines local or [[start#formal]] [[start#generic]] [[start#constant]]s. (§1.1.1.1, §4.3.2.1)

==== globally static expression ====
An [[start#expression]] that can be evaluated as soon as the [[start#design hierarchy]] in which it appears is elaborated. A [[start#locally static expression]] is also globally static unless the expression appears in a dynamically elaborated context. (§7.4)

==== globally static primary ====
A [[start#primary]] whose value can be determined during the [[start#elaboration]] of its [[start#complete context]] and that does not thereafter change. Globally [[start#static]] primaries can only appear within statically elaborated contexts. (§7.4.2)

==== group ====
A named collection of [[start#name entity|name entities]]. Groups relate different name entities for the purposes not specified by the language. In particular, groups may be decorated with [[start#attribute]]s. (§4.6, §4.7)

==== guard ====
//See// [[start#guard expression]].

==== guard expression ====
A Boolean-valued [[start#expression]] associated with a [[start#block]] statement that controls assignments to [[start#guarded signal]]s within the block. A guard expression defines an [[start#implicit signal]] GUARD that may be used to control the operation of certain statements within the block. (§4.3.1.2, §9.1, §9.5)

==== guarded assignment ====
A concurrent [[start#signal]] assignment statement that includes the option **guarded**, which specifies that the signal assignment statement is executed when a signal GUARD changes from FALSE to TRUE, or when that signal has been TRUE and an [[start#event]] occurs on one of the signals referenced in the corresponding [[start#GUARD expression]]. The signal GUARD may be one of the implicitly declared GUARD signals associated with [[start#block]] statements that have guard expressions, or it may be an explicitly declared signal of [[start#type]] Boolean that is [[start#visible]] at the point of the concurrent signal assignment statement. (§9.5)

==== guarded signal ====
A [[start#signal]] declared as a [[start#register]] or a [[start#bus]]. Such signals have special semantics when their [[start#driver]]s are updated from within guarded signal assignment statements. (§4.3.1.2)

==== guarded target ====
A [[start#signal]] assignment target consisting only of [[start#guarded signal]]s. An unguarded target is a target consisting only of unguarded signals. (§9.5)

===== H =====
==== hidden ====
A [[start#declaration]] that is not [[start#directly visible]]. A declaration may be //hidden// in its [[start#scope]] by a [[start#homograph]] of the declaration. (§10.3)

==== homograph ====
A reflexive property of two [[start#declaration]]s. Each of two declarations is said to be a //homograph// of the other if both declarations have the same identifier and overloading is allowed for at most one of the two. If [[start#overloading]] is allowed for both declarations, then each of the two is a homograph of the other if they have the same identifier, operator symbol, or [[start#character literal]], as well as the same [[start#parameter and result type profile]]. (§1.3.1, §10.3)

===== I =====
==== identify ====
A property of a [[start#name]] appearing in an element association of an assignment target in the form of an [[start#aggregate]]. The name is said to //identify// a [[start#signal]] or [[start#variable]] and any [[start#subelement]]s of that signal or variable. (§8.4, §8.5)

==== immediate scope ====
A property of a [[start#declaration]] with respect to the [[start#declarative region]] within which the declaration immediately occurs. The immediate scope of the declaration extends from the beginning of the declaration to the end of the declarative region. (§10.2)

==== immediately within ====
A property of a [[start#declaration]] with respect to some [[start#declarative region]]. A declaration is said to occur //immediately within// a declarative region if this region is the innermost region that encloses the declaration, not counting the declarative region (if any) associated with the declaration itself. (§10.1)

==== implicit signal ====
Any [[start#signal]] S'Stable(T), S'Quiet(T), S'Delayed, or S'Transaction, or any implicit [[start#GUARD]] signal. A [[start#member]] of an implicit signal is also an implicit signal. (§12.6.2,§12.6.3, §12.6.4)

==== implicitly declared object ====
An [[start#object]] whose [[start#declaration]] is not explicit in the source description, but is a consequence of other constructs; for example, signal [[start#GUARD]]. (§4.3, §9.1, §14.1) //See also// [[start#explicitly declared object]].

==== imply ====
A property of a [[start#binding]] indication in a [[start#configuration]] [[start#specification]] with respect to the [[start#design entity]] indicated by the binding specification. The binding indication is said to //imply// the design entity; the design entity may be indicated directly, indirectly, or by default. (§5.2.1.1)

==== impure function ====
A function that may return a different value each time it is called, even when different calls have the same actual [[start#parameter]] values. A [[start#pure function]] returns the same value each time it is called using the same values as [[start#actual]] parameters. A impure function can [[start#update]] [[start#object]]s outside of its [[start#scope]] and can access a broader class of values than a pure function. (§2)

==== incomplete type declaration ====
A [[start#type]] [[start#declaration]] that is used to {define} mutually dependent and recursive [[start#access type]]s. (§3.3.1)

==== index constraint ====
A [[start#constraint]] that determines the [[start#index range]] for every index of an [[start#array type]], and thereby the bounds of the array. An index constraint is //compatible// with an array type if and only if the constraint defined by each [[start#discrete range]] in the index constraint is compatible with the corresponding [[start#index subtype]] in the array type. An array value //satisfies// an index constraint if the array value and the index constraint have the same index range at each index position . (§3.1, §3.2.1.1)

==== index range ====
A multidimensional array has a distinct element for each possible sequence of index values that can be formed by selecting one value for each index (in the given order). The possible values for a given index are all the values that belong to the corresponding [[start#range]]. This range of values is called the //index range//. (§3.2.1)

==== index subtype ====
For a given index position of an array, the //index subtype// is denoted by the [[start#type]] mark of the corresponding index [[start#subtype]] definition. (§3.2.1)

==== inertial delay ====
A delay [[start#model]] used for switching circuits; a pulse whose duration is shorter than the switching time of the circuit will not be transmitted. Inertial delay is the default delay mode for [[start#signal]] assignment statements. (§8.4) //See also// [[start#transport delay]].

==== initial value expression ====
An [[start#expression]] that specifies the initial value to be assigned to a [[start#variable]]. (§4.3.1.3)

==== inputs ====
The [[start#signal]]s identified by the [[start#longest static prefix]] of each signal [[start#name]] appearing as a [[start#primary]] in each [[start#expression]] (other than time expressions) within a concurrent signal assignment statement. (§9.5)

==== instance ====
A subcomponent of a [[start#design entity]] whose prototype is a component [[start#declaration]], design entity, or [[start#configuration]] declaration. Each instance of a component may have different [[start#actual]]s associated with its [[start#local port]]s and [[start#generic]]s. A component instantiation statement whose instantiated unit denotes a component creates an instance of the corresponding component. A component instantiation statement whose instantiated unit denotes either a design entity or a configuration declaration creates an instance of the denoted design entity. (§9.6, §9.6.1, §9.6.2)

==== integer literal ====
An [[start#abstract literal]] of the [[start#type]] [[start#universal_integer]] that does not contain a base point. (§13.4)

==== integer type ====
A discrete [[start#scalar type]] whose values represent integer numbers within a specified [[start#range]]. (§3.1, §3.1.2)

==== interface list ====
A list that declares the interface [[start#object]]s required by a subprogram, component, [[start#design entity]], or [[start#block]] statement. (§4.3.2.1)

==== internal block ====
A nested block in a design unit, as defined by a block statement. (§1)

==== ISO ====
The International Organization for Standardization.

==== ISO 8859-1 ====
The [[start#ISO]] Latin-l character set. Package Standard contains the definition of [[start#type]] Character, which represents the ISO Latin-l character set. (§3.1.1, §14.2)

===== K =====
==== kernel process ====
A conceptual representation of the agent that coordinates the activity of user-defined processes during a simulation. The kernel process causes the execution of I/O operations, the propagation of [[start#signal]] values, and the updating of values of [[start#implicit signal]]s [such as S'Stable(T)]; in addition, it detects [[start#event]]s that occur and causes the appropriate processes to [[start#execute]] in response to those events. (§12.6)

===== L =====
==== left of ====
When both a value V1 and a value V2 [[start#belong to a range]] and either the [[start#range]] is an [[start#ascending range]] and V2 is the successor of V1, or the range is a [[start#descending range]] and V2 is the predecessor of V1. (§3.1)

==== left-to-right order ====
When each value in a list of values is to the left of the next value in the list within that [[start#range]], except for the last value in the list. (§3.1)

==== library ====
//See// [[start#design library]].

==== library unit ====
The representation in a [[start#design library]] of an analyzed [[start#design unit]]. (§11.1)

==== literal ====
A value that is directly specified in the description of a design. A literal can be a [[start#bit string literal]], [[start#enumeration literal]], [[start#numeric literal]], [[start#string literal]], or the literal **null**. (§7.3.1)

==== local generic ====
An interface [[start#object]] declared in a component [[start#declaration]] that serves to connect a [[start#formal]] generic in the [[start#interface list]] of an entity and an [[start#actual]] generic or value in the [[start#design unit]] instantiating that entity. (§4.3, §4.3.2.2, §4.5)

==== local port ====
A [[start#signal]] declared in the [[start#interface list]] of a component [[start#declaration]] that serves to connect a [[start#formal]] port in the interface list of an entity and an [[start#actual]] port or signal in the [[start#design unit]] instantiating that entity. (§4.3, §4.3.2.2, §4.5)

==== locally static expression ====
An [[start#expression]] that can be evaluated during the [[start#analysis]] of the [[start#design unit]] in which it appears. (§7.4, §7.4.1)

==== locally static name ====
A [[start#name]] in which every [[start#expression]] is locally [[start#static]] (if every [[start#discrete range]] that appears as part of the name denotes a locally [[start#static range]] or [[start#subtype]] and if no prefix within the name is either an [[start#object]] or value of an [[start#access type]] or a function call). (§6.1)

==== locally static primary ====
One of a certain group of primaries that includes [[start#literal]]s, certain [[start#constant]]s, and certain [[start#attribute]]s. (§7.4)

==== locally static subtype ====
A [[start#subtype]] whose [[start#bound]]s and direction can be determined during the [[start#analysis]] of the [[start#design unit]] in which it appears. (§7.4.1)

==== longest static prefix ====
The [[start#name]] of a [[start#signal]] or a [[start#variable]] name, if the name is a [[start#static signal]] or [[start#variable name]]. Otherwise, the longest static prefix is the longest prefix of the name that is a static signal or variable name. (§6.1) //See also// [[start#static signal name]].

==== loop parameter ====
A [[start#constant]], implicitly declared by the for clause of a loop statement, used to count the number of iterations of a loop. (§8.9)

==== lower bound ====
For a nonnull [[start#range]] L **to** R or L **downto** R, the smaller of L and R. (§3.1)

===== M =====
==== match ====
A property of a signature with respect to the [[start#parameter]] and [[start#subtype]] profile of a subprogram or [[start#enumeration literal]]. The signature is said to match the [[start#parameter and result type profile]] if certain conditions are true. (§2.3.2)

==== matching elements ====
Corresponding elements of two [[start#composite type]] values that are used for certain logical and relational operations. (§7.2.3)

==== member ====
A [[start#slice]] of an [[start#object]], a [[start#subelement]], or an object; or a slice of a subelement of an object. (§3)

==== mode ====
The direction of information flow through the [[start#port]] or [[start#parameter]]. Modes are **in**, **out**, **inout**, **buffer**, or **linkage**. (§4.3.2)

==== model ====
The result of the [[start#elaboration]] of a [[start#design hierarchy]]. The //model// can be executed in order to simulate the design it represents. (§12, §12.6)

===== N =====
==== name ====
A property of an identifier with respect to some [[start#named entity]]. Each form of [[start#declaration]] associates an identifier with a named entity. In certain places within the [[start#scope]] of a declaration, it is valid to use the identifier to refer to the associated named entity; these places are defined by the visibility rules. At such places, the identifier is said to be the //name// of the named entity. (§4, §6.1)

==== named association ====
An [[start#association element]] in which the [[start#formal]] [[start#designator]] appears explicitly. (§4.3.2.2, §7.3.2)

==== named entity ====
An item associated with an identifier, [[start#character literal]], or operator symbol as the result of an explicit or implicit [[start#declaration]]. (§4) //See also// [[start#name]].

==== net ====
A collection of [[start#driver]]s, [[start#signal]]s (including [[start#port]]s and [[start#implicit signal]]s), [[start#conversion function]]s, and [[start#resolution function]]s that connect different processes. Initialization of a net occurs after [[start#elaboration]], and a net is updated during each [[start#simulation cycle]]. (§12, §12.1, §12.6.2)

==== nonobject alias ====
An [[start#alias]] whose [[start#designator]] denotes some [[start#named entity]] other than an [[start#object]]. (§4.3.3, §4.3.3.2) //See also// [[start#object alias]].

==== nonpostponed process ====
An explicit or implicit process whose source statement does not contain the reserved word **postponed**. When a nonpostponed process is resumed, it [[start#execute]]s in the current [[start#simulation cycle]]. Thus, nonpostponed processes have access to the [[start#current value]]s of [[start#signal]]s, whether or not those values are stable at the current [[start#model]] time. (§9.2)

==== null array ====
Any of the [[start#discrete range]]s in the [[start#index constraint]] of an array that define a [[start#null range]]. (§3.2.1.1)

==== null range ====
A [[start#range]] that specifies an empty subset of values. A range L **to** R is a null range if L > R, and range L **downto** R is a null range if L < R. (§3.1)

==== null slice ====
A [[start#slice]] whose [[start#discrete range]] is a [[start#null range]]. (§6.5)

==== null waveform element ====
A [[start#waveform]] element that is used to turn off a [[start#driver]] of a [[start#guarded signal]]. (§8.4.1)

==== null transaction ====
A [[start#transaction]] produced by evaluating a [[start#null waveform element]]. (§8.4.1)

==== numeric literal ====
An [[start#abstract literal]], or a [[start#literal]] of a [[start#physical type]]. (§7.3.1)

==== numeric type ====
An [[start#integer type]], a [[start#floating point type]], or a [[start#physical type]]. (§3.1)

===== O =====
==== object ====
A [[start#named entity]] that has a value of a given [[start#type]]. An [[start#object]] can be a [[start#constant]], [[start#signal]], [[start#variable]], or file. (§4.3.3)

==== object alias ====
An [[start#alias]] whose alias [[start#designator]] denotes an [[start#object]] (that is, a [[start#constant]], [[start#signal]], [[start#variable]], or file). (§4.3.3, §4.3.3.1) //See also// [[start#nonobject alias]].

==== overloaded ====
Identifiers or [[start#enumeration literals]] that denote two different [[start#name entity|name entities]]. Enumeration literals, subprograms, and [[start#predefined operator]]s may be overloaded. At any place where an overloaded enumeration literal occurs in the text of a program, the [[start#type]] of the enumeration literal must be determinable from the context. (§2.1, §2.3, §2.3.1, §2.3.2, §3.1.1)

===== P =====
==== parameter ====
A [[start#constant]], [[start#signal]], [[start#variable]], or file declared in the [[start#interface list]] of a [[start#subprogram specification]]. The characteristics of the class of [[start#object]]s to which a given parameter belongs are also characteristics of the parameter. In addition, a parameter has an associated [[start#mode]] that specifies the direction of data flow allowed through the parameter. (§2.1.1, §2.1.1.1, §2.1.1.2, §2.1.1.3, §2.3, §2.6)

==== parameter interface list ====
An [[start#interface list]] that declares the [[start#parameter]]s for a subprogram. It may contain interface [[start#constant]] [[start#declarations]], interface [[start#signal]] declarations, interface [[start#variable]] declarations, interface file declarations, or any combination thereof. (§4.3.2.1)

==== parameter type profile ====
Two [[start#formal]] parameter lists that have the same number of [[start#parameter]]s, and at each parameter position the corresponding parameters have the same base [[start#type]]. (§2.3)

==== parameter and result type profile ====
Two subprograms that have the same [[start#parameter type profile]], and either both are functions with the same result base [[start#type]], or neither of the two is a function. (§2.3)

==== parent ====
A process or a subprogram that contains a procedure call statement for a given procedure or for a parent of the given procedure. (§2.2)

==== passive process ====
A process statement where neither the process itself, nor any procedure of which the process is a [[start#parent]], contains a [[start#signal]] assignment statement. (§9.2)

==== physical literal ====
A [[start#numeric literal]] of a [[start#physical type]]. (§3.1.3)

==== physical type ====
A numeric [[start#scalar type]] that is used to represent measurements of some quantity. Each value of a physical type has a position number that is an integer value. Any value of a physical type is an integral multiple of the primary unit of measurement for that [[start#type]]. (§3.1, §3.1.3)

==== port ====
A channel for dynamic communication between a [[start#block]] and its environment. A [[start#signal]] declared in the [[start#interface list]] of an [[start#entity declaration]], in the header of a block statement, or in the interface list of a component [[start#declaration]]. In addition to the characteristics of signals, ports also have an associated [[start#mode]]; the mode constrains the directions of data flow allowed through the port. (§1.1.1.2, §4.3.1.2)

==== port interface list ====
An [[start#interface list]] that declares the inputs and outputs of a [[start#block]], component, or [[start#design entity]]. It consists entirely of interface [[start#signal]] [[start#declarations]]. (§1.1.1, §1.1.1.2, §4.3.2.1, §4.3.2.2, §9.1)

==== positional association ====
An [[start#association element]] that does not contain an explicit appearance of the [[start#formal]] [[start#designator]]. An [[start#actual]] designator at a given position in an [[start#association list]] corresponds to the interface element at the same position in the [[start#interface list]]. (§4.3.2.2, §7.3.2)

==== postponed process ====
An explicit or implicit process whose source statement contains the reserved word **postponed**. When a postponed process is resumed, it does not [[start#execute]] until the final [[start#simulation cycle]] at the current modeled time. Thus, a postponed process accesses the values of [[start#signal]]s that are the "stable" values at the current simulated time. (§9.2)

==== predefined operators ====
Implicitly defined operators that operate on the predefined [[start#type]]s. Every predefined operator is a [[start#pure function]]. No predefined operators have named [[start#formal]] [[start#parameter]]s; therefore, [[start#named association]] may not be used when invoking a predefined operation. (§7.2, §14.2)

==== primary ====
One of the elements making up an [[start#expression]]. Each primary has a value and a [[start#type]]. (§7.1)

==== projected output waveform ====
A sequence of one or more [[start#transaction]]s representing the current and projected future values of the [[start#driver]]. (§12.6.1)

==== pulse rejection limit ====
The threshold time limit for which a [[start#signal]] value whose duration is greater than the limit will be propagated. A pulse rejection limit is specified by the reserved word **reject** in an inertially delayed signal assignment statement. (§8.4)

==== pure function ====
A function that returns the same value each time it is called with the same values as [[start#actual]] [[start#parameter]]s. An [[start#impure function]] may return a different value each time it is called, even when different calls have the same actual parameter values. (§2.1)

===== Q =====
==== quiet ====
In a given [[start#simulation cycle]], a [[start#signal]] that is not active. (§12.6.2)

===== R =====
==== range ====
A specified subset of values of a [[start#scalar type]]. (§3.1) //See also// [[start#ascending range]], [[start#belong (to a range)]], [[start#descending range]], [[start#lower bound]], and [[start#upper bound]].

==== range constraint ====
A construct that specifies the [[start#range]] of values in a [[start#type]]. A range constraint is //compatible// with a [[start#subtype]] if each bound of the range [[start#belong (to a subtype)]] or if the range constraint defines a [[start#null range]]. The direction of a range constraint is the same as the direction of its range. (§3.1, §3.1.2, §3.1.3, §3.1.4)

==== read ====
The value of an [[start#object]] is said to be //read// when its value is referenced or when certain of its [[start#attribute]]s are referenced. (§4.3.2)

==== real literal ====
An [[start#abstract literal]] of the [[start#type]] [[start#universal_real]] that contains a base point. (§13.4)

==== record type ====
A [[start#composite type]] whose values consist of named elements. (§3.2.2, §7.3.2.1)

==== reference ====
Access to a [[start#named entity]]. Every appearance of a [[start#designator]] (a [[start#name]], [[start#character literal]], or operator symbol) is a reference to the named entity denoted by the designator, unless the designator appears in a [[start#library]] clause or use clause. (§10.4, §11.2)

==== register ====
A kind of [[start#guarded signal]] that retains its last driven value when all of its [[start#driver]]s are turned off. (§4.3.1.2)

==== regular structure ====
[[start#Instance]]s of one or more components arranged and interconnected (via [[start#signal]]s) in a repetitive way. Each instance may have characteristics that depend upon its position within the [[start#group]] of instances. Regular structures may be represented through the use of the generate statement. (§9.7)

==== resolution ====
The process of determining the [[start#resolved value]] of a [[start#resolved signal]] based on the values of multiple [[start#sources]] for that [[start#signal]]. (§2.4, §4.3.1.2)

==== resolution function ====
A user-defined function that computes the [[start#resolved value]] of a [[start#resolved signal]]. (§2.4, §4.3.1.2)

==== resolution limit ====
The primary unit of [[start#type]] TIME (by default, 1 femtosecond). Any TIME value whose absolute value is smaller than this limit is truncated to zero (0) time units. (§3.1.3.1)

==== resolved signal ====
A [[start#signal]] that has an associated [[start#resolution function]]. (§4.3.1.2)

==== resolved value ====
The output of the [[start#resolution function]] associated with the [[start#resolved signal]], which is determined as a function of the collection of [[start#inputs]] from the multiple [[start#source]]s of the [[start#signal]]. (§2.4, §4.3.1.2)

==== resource library ====
A [[start#library]] containing [[start#library units]] that are referenced within the [[start#design unit]] being analyzed. (§11.2)

==== result subtype ====
The [[start#subtype]] of the returned value of a function. (§2.1)

==== resume ====
The action of a wait statement upon an enclosing process when the conditions on which the wait statement is waiting are satisfied. If the enclosing process is a [[start#nonpostponed process]], the process will subsequently [[start#execute]] during the current [[start#simulation cycle]]. Otherwise, the process is a [[start#postponed process]], which will execute during the final simulation cycle at the current simulated time. (§12.6.3)

==== right of ====
When a value V1 and a value V2 [[start#belong (to a range)]] and either the [[start#range]] is an [[start#ascending range]] and V2 is the predecessor of V1, or the range is a [[start#descending range]] and V2 is the successor of V1. (§14.1)

===== S =====
==== satisfy ====
A property of a value with respect to some [[start#constraint]]. The value is said to //satisfy// a constraint if the value is in the subset of values determined by the constraint. (§3, §3.2.1.1)

==== scalar type ====
A [[start#type]] whose values have no elements. Scalar types consist of [[start#enumeration type]]s, [[start#integer type]]s, [[start#physical type]]s, and [[start#floating point types]]. Enumeration types and integer types are called [[start#discrete type]]s. Integer types, floating point types, and physical types are called [[start#numeric type]]s. All scalar types are ordered; that is, all relational operators are predefined for their values. (§3, §3.1)

==== scope ====
A portion of the text in which a [[start#declaration]] may be [[start#visible]]. This portion is defined by visibility and overloading rules. (§10.2)

==== selected name ====
Syntactically, a [[start#name]] having a prefix and suffix separated by a dot. Certain selected names are used to denote record elements or [[start#object]]s denoted by an [[start#access value]]. The remaining selected names are referred to as expanded names. (§6.3, §8.1) //Also see// [[start#expanded name]].

==== sensitivity set ====
The set of [[start#signal]]s to which a wait statement is sensitive. The sensitivity set is given explicitly in an on clause, or is implied by an **until** clause. (§8.1)

==== sequential statements ====
Statements that [[start#execute]] in sequence in the order in which they appear. Sequential statements are used for algorithmic descriptions. (§8)

==== short-circuit operation ====
An operation for which the right operand is evaluated only if the left operand has a certain value. The short-circuit operations are the predefined logical operations **and**, **or**, **nand**, and **nor** for operands of [[start#type]]s BIT and BOOLEAN. (§7.2)

==== signal ====
An [[start#object]] with a past history of values. A signal may have multiple [[start#driver]]s, each with a [[start#current value]] and projected future values. The term //signal// refers to objects declared by signal [[start#declaration]]s or [[start#port]] declarations. (§4.3.1.2)

==== signal transform ====
A sequential statement within a [[start#statement transform]] that determines which one of the alternative [[start#waveform]]s, if any, is to be assigned to an output [[start#signal]]. A signal transform can be a sequential signal assignment statement, an if statement, a case statement, or a null statement. (§9.5)

==== simple name ====
The identifier associated with a [[start#named entity]], either in its own [[start#declaration]] or in an [[start#alias]] declaration. (§6.2)

==== simulation cycle ====
One iteration in the repetitive execution of the processes defined by process statements in a [[start#model]]. The first simulation cycle occurs after initialization. A simulation cycle can be a [[start#delta cycle]] or a time-advance cycle. (§12.6.4)

==== single-object declaration ====
An [[start#object]] [[start#declaration]] whose identifier list contains a single identifier; it is called a multiple-object declaration if the identifier list contains two or more identifiers. (§4.3.1)

==== slice ====
A one-dimensional array of a sequence of consecutive elements of another one-dimensional array. (§6.5)

==== source ====
A contributor to the value of a [[start#signal]]. A source can be a [[start#driver]] or [[start#port]] of a [[start#block]] with which a signal is associated or a composite collection of sources. (§4.3.1.2)

==== specification ====
A class of construct that associates additional information with a [[start#named entity]]. There are three kinds of [[start#attribute]] specifications, [[start#configuration]] specifications, and disconnection specifications. (§5)

==== statement transform ====
The first sequential statement in the process equivalent to the concurrent [[start#signal]] assignment statement. The statement transform defines the actions of the concurrent signal assignment statement when it executes. The statement transform is followed by a wait statement, which is the final statement in the equivalent process. (§9.5)

==== static ====
//See// [[start#locally static expression]] and [[start#globally static expression]].

==== static name ====
A [[start#name]] in which every [[start#expression]] that appears as part of the name (for example, as an index expression) is a [[start#static]] expression (if every [[start#discrete range]] that appears as part of the name denotes a [[start#static range]] or [[start#subtype]] and if no prefix within the name is either an [[start#object]] or value of an [[start#access type]] or a function call). (§6.1)

==== static range ====
A [[start#range]] whose bounds are [[start#static]] [[start#expressions]]. (§7.4)

==== static signal name ====
A [[start#static name]] that denotes a [[start#signal]]. (§6.1)

==== static variable name ====
A [[start#static name]] that denotes a [[start#variable]]. (§6.1)

==== string literal ====
A sequence of graphic characters, or possibly none, enclosed between two quotation marks ("). The [[start#type]] of a string literal is determined from the context. (§7.3.1, §13.6)

==== subaggregate ====
An [[start#aggregate]] appearing as the [[start#expression]] in an element association within another, multidimensional [[start#array]] aggregate. The subaggregate is an (//n//-1)-dimensional array aggregate, where //n// is the dimensionality of the outer aggregate. Aggregates of multidimensional arrays are expressed in row-major (rightmost index varies fastest) order. (§7.3.2.2)

==== subelement ====
An element of another element. Where other subelements are excluded, the term //element// is used.(§3)

==== subprogram specification ====
Specifies the designator of the [[start#subprogram]], any [[start#formal]] [[start#parameter]]s of the subprogram, and the result [[start#type]] for a function subprogram. (§2.1)

==== subtype ====
A [[start#type]] together with a [[start#constraint]]. A value [[start#belongs (to a subtype)]] of a given type if it belongs to the type and satisfies the constraint; the given type is called the [[start#base type]] of the subtype. A type is a subtype of itself. Such a subtype is said to be //unconstrained// because it corresponds to a condition that imposes no restriction. (§3)

==== suspend ====
A process that stops executing and waits for an [[start#event]] or for a time period to elapse. (§12.6.4)

===== T =====
==== timeout interval ====
The maximum time a process will be suspended, as specified by the timeout period in the **until** clause of a wait statement. (§8.1)

==== to the left of ====
//See// [[start#left of]].

==== to the right of ====
//See// [[start#right of]].

==== transaction ====
A pair consisting of a value and a time. The value represents a (current or) future value of the [[start#driver]]; the time represents the relative delay before the value becomes the [[start#current value]]. (§12.6.1)

==== transport delay ====
An optional delay model for [[start#signal]] assignment. Transport delay is characteristic of hardware devices (such as transmission lines) that exhibit nearly infinite frequency response: any pulse is transmitted, no matter how short its duration. (§8.4) //See also// [[start#inertial delay]].

==== type ====
A set of values and a set of operations. (§3)

==== type conversion ====
An [[start#expression]] that converts the value of a subexpression from one [[start#type]] to the designated type of the type conversion. Associations in the form of a type conversion are also allowed. These associations have functions and restrictions similar to conversion functions but can be used in places where conversion functions cannot. In both cases (expressions and associations), the converted type must be closely related to the [[start#designated type]]. (§4.3.2.2, §7.3.5) //See also// [[start#conversion function]] and [[start#closely related types]].

===== U =====
==== unaffected ====
A [[start#waveform]] in a concurrent [[start#signal]] assignment statement that does not affect the [[start#driver]] of the target. (§8.4, §9.5.1)

==== unassociated formal ====
A [[start#formal]] that is not associated with an [[start#actual]]. (§5.2.1.2)

==== unconstrained subtype ====
A [[start#subtype]] that corresponds to a condition that imposes no restriction. (§3, §4.2)

==== unit name ====
A [[start#name]] defined by a unit [[start#declaration]] (either the primary unit declaration or a secondary unit declaration) in a [[start#physical type]] declaration. (§3.1.3)

==== universal_integer ====
An [[start#anonymous]] predefined [[start#integer type]] that is used for all [[start#integer literal]]s. The position number of an integer value is the corresponding value of the [[start#type]] universal_integer. (§3.1.2, §7.3.1, §7.3.5)

==== universal_real ====
An [[start#anonymous] predefined [[start#type]] that is used for [[start#literal]]s of [[start#floating point types]]. Other floating point types have no literals. However, for each floating point type there exists an implicit conversion that converts a value of type universal_real into the corresponding value (if any) of the floating point type. (§3.1.4, §7.3.1, §7.3.5)

==== update ====
An action on the value of a [[start#signal]], [[start#variable]], or file. The value of a signal is said to be //updated// when the signal appears as the target (or a component of the target) of a signal assignment statement, (indirectly) when it is associated with an interface [[start#object]] of [[start#mode]] **out**, **buffer**, **inout**, or **linkage**, or when one of its [[start#subelement]]s (individually or as part of a [[start#slice]]) is updated. The value of a signal is also said to be updated when it is subelement or slice of a [[start#resolved signal]], and the resolved signal is updated. The value of a variable is said to be //updated// when the variable appears as the target (or a component of the target) of a variable assignment statement, (indirectly) when it is associated with an interface object of mode **out** or **linkage**, or when one of its subelements (individually or part of a slice) is updated. The value of a file is said to be //updated// when a WRITE operation is performed on the file object. (§4.3.2)

==== upper bound ====
For a nonnull [[start#range]] L **to** R or L **downto** R, the larger of L and R. (§3.1)

===== V =====
==== variable ====
An [[start#object]] with a single [[start#current value]]. (§4.3.1.3)

==== visible ====
When the [[start#declaration]] of an identifier defines a possible meaning of an occurrence of the identifier used in the declaration. A visible declaration is visible by selection (for example, by using an [[start#expanded name]]) or [[start#directly visible]] (for example, by using a [[start#simple name]]). (§10.3)

===== W =====
==== waveform ====
A series of [[start#transaction]]s, each of which represents a future value of the [[start#driver]] of a [[start#signal]]. The transactions in a waveform are ordered with respect to time, so that one transaction appears before another if the first represents a value that will occur sooner than the value represented by the other. (§8.4)

==== whitespace character ====
A space, a nonbreaking space, or a horizontal tabulation character (SP, NBSP, or HT). (§14.3)

==== working library ====
A [[start#design library]] into which the [[start#library unit]] resulting from the [[start#analysis]] of a [[start#design unit]] is placed. (§11.2)

End of document.