====== VHDL Glossar ======
//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.//

Dieses Glossar enthält kurze Informationen zu einer Menge von Ausdrücken und Phrasen, die zur Definition von VHDL verwendet werden. Es ist eine erweiterte Version des Anhangs B des LRM (Language Reference Manual). Die komplette formelle Definition eines jeden Ausdrucks wird innerhalb des Hauptteils des LRM beschrieben. Dieses Glossar soll helfen sich leichter an den Sinn eines bestimmten Ausdrucks zu erinnern. Erweiterte Grundkenntnisse in VHDL sind aber vorauszusetzen. Die Übersetzung von Englisch nach Deutsch erfolgte nach dem Prinzipien:
  - Keine Übersetzung von dem, was eindeutig ist - object -> Objekt (z.B.)
  - Keine Übersetzung von VHDL-spezifischen Ausdrücken, die außerdem erklärt werden - literal.

===== A =====
==== abstract literal ====
Ein [[VHDL Glossar#literal]] aus der Menge der abstrakten Typen ( [[VHDL Glossar#type]] ) [[VHDL Glossar#universal_real]] oder [[VHDL Glossar#universal_integer]]. (§13.2, §13.4)

==== access type ====
Ein Typ ( [[VHDL Glossar#type]] ) der den Zugriff auf ein Objekt ( [[VHDL Glossar#object]] ) eines vorgegebenen Typs erlaubt. Der Zugriff auf ein solches Objekt wird erreicht über einen [[VHDL Glossar#access value]] , der von einem [[VHDL Glossar#allocator]] (Zeiger) übergeben wird; man sagt der access value bestimmt ( [[VHDL Glossar#designate]] ) das Objekt. (§3, §13.3)

==== access mode ====
Der Modus ( [[VHDL Glossar#mode]] ) in dem eine Datei entweder mit einem read-only- oder einem write-only-Zugriff geöffnet wird. Der Zugriffsmodus ( //access mode// ) hängt von dem mitgelieferten Open_Kind-Parameter ab. (§3.4.1, §14.3).

==== access value ====
Der Zugriffswert ( //access value// ) ist der Wert eines Zugrifftyps ( [[VHDL Glossar#access type]] ). Dieser Wert wird von einem [[VHDL Glossar#allocator]] übergeben und bezeichnet ( [[VHDL Glossar#designate]] ) ein [[VHDL Glossar#object]] eines vorgegebenen Typs ( [[VHDL Glossar#type]] ); das Objekt muß eine [[VHDL Glossar#variable]] dieses Typs sein. Ein //access value// mit dem Wert Null bezeichnet ( designate ) kein object . Ein //access value// kann nur ein von einem allocator erzeugtes Objekt bezeichnen, also kein Objekt, daß über eine [[VHDL Glossar#declaration]] definiert wurde. (§3, 3.3)

==== active driver ====
Ein Treiber ( [[VHDL Glossar#driver]] ) der während eines Simulationszyklusses ( [[VHDL Glossar#simulation cycle]] ) einen neuen Wert annimmt, ungeachtet dessen, ob der Wert zu dem vorhergehenden Wert verschieden ist. (§12.6.2, §12.6.4)

==== actual ====
Ein Ausdruck ( [[VHDL Glossar#expression]] ), ein Ein-/Ausgang ( [[VHDL Glossar#port]] ), ein Signal ( [[VHDL Glossar#signal]] ), oder eine Variable ( [[VHDL Glossar#variable]] ) verbunden mit einem formal Ein-/Ausgang ( [[VHDL Glossar#formal]] [[VHDL Glossar#port]] ), formellen Parameter ( formal [[VHDL Glossar#parameter]] ) oder einer formellen allgemeinen Konstante ( formal [[VHDL Glossar#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 ====
  - Ein Ausdruck ( [[VHDL Glossar#expression]] ), der den Wert eines kombinierten Typs ( [[VHDL Glossar#composite type]] ) kennzeichnet. Der Wert wird durch die Übergabe aller zu den Elementen des composite type gehörenden Werten spezifiziert. Es kann entweder eine Positionszuweisung ( [[VHDL Glossar#positional association]] ) oder eine namentliche Zuweisung ( [[VHDL Glossar#named association]] ) zur Darstellung - welcher Wert wurde welchem Element zugewiesen - verwendet werden.
  - Ein Zielwert einer Variablenzuweisung ( [[VHDL Glossar#variable]] assignment) oder Signalzuweisung [[VHDL Glossar#signal]] assignment), das einen kombinierten Wert zuordnet. Man spricht von diesem Zielwert als //form of an aggregate// . (§7.3.1, §7.3.2, §7.3.4, 7.3.5, §7.5.2)

==== alias ====
Der alternative [[VHDL Glossar#name]] für eine [[VHDL Glossar#named entity]] . (§4.3.3)

==== allocator ====
Ein Befehl der verwendet wird, um anonyme ( [[VHDL Glossar#anonymous]] ), variable ( [[VHDL Glossar#variable]] [[VHDL Glossar#object]] ) Objekte zu erzeugen, die mittels bestimmter Werte ( [[VHDL Glossar#access value]]) zugänglich sind. (§3.3, §7.3.6)

==== analysis ====
Die syntaktische und semantische Analyse von VHDL-Quellcode in einem VHDL-Design ( [[VHDL Glossar#design file]] ) und das Einfügen einer zwischenzeitlichen Darstellungsform von Entwurfseinheiten ( [[VHDL Glossar#design unit]] ) in eine Entwurfsbibliothek ( [[VHDL Glossar#design library]] ). (§1 1.1, §11.2, §11.4)

==== anonymous ====
Der undefinierte einfache Name ( [[VHDL Glossar#simple name]] ) eines Begriffs, welcher implizit erzeugt wird. Der Basistyp ( [[VHDL Glossar#base type]] ) eines numerischen Typs ( [[VHDL Glossar#numeric type]] ) oder eines Feldtyps ( [[VHDL Glossar#array type]] ) ist anonym; ähnlich ist ein durch einen Zugriffswert ( [[VHDL Glossar#access value]] ) bezeichnetes Objekt ( [[VHDL Glossar#object]] [[VHDL Glossar#denote]] ) anonym. (§4.1)

==== appropriate ====
Ein Präfix wird als passend ( [[VHDL Glossar#appropriate]] ) für einen Typ ( [[VHDL Glossar#type]] ) bezeichnet, falls der Präfix den gleichen Typ besitzt, oder falls der Typ des Präfix ein Zugriffstyp ( [[VHDL Glossar#access type]] ) ist, dessen Zieltyp [[VHDL Glossar#designated type]] gleich dem oben betrachteten Typ ist. (§6.1)

==== architecture body ====
Ein Basiskonstrukt, das mit einer [[VHDL Glossar#entity declaration]] zur Beschreibung der internen Funktion und des Aufbaus einer [[VHDL Glossar#design entity]] verbunden wird. Ein architecture body wird verwendet, um das Verhalten, den Datenfluss oder die Struktur einer design entity zu beschreiben. (§1, §1.2)

==== array object ====
Ein [[VHDL Glossar#object]] eines [[VHDL Glossar#array type]] . (§3)

==== array type ====
Der Typ ( [[VHDL Glossar#type]] ), dessen Wert sich aus Elementen zusammensetzt, die alle zu dem gleichen Untertyp ( [[VHDL Glossar#subtype]] ) gehören (und deshalb vom gleichen type sind). Jedes Element wird eindeutig über einen Zeiger (im Falle eines Vektors) oder über eine Folge von Zeigern (im Falle einer mehrdimensionalen Matrix) gekennzeichnet. Jeder Zeiger setzt sich aus dem Wert eines [[VHDL Glossar#discrete type]] zusammen und muß innerhalb des passenden [[VHDL Glossar#index range]] liegen. (§3.2.1)

==== ascending range ====
Ein [[VHDL Glossar#range]] L to R. (§3.1)

==== ASCII ====
American Standard Code for Information Interchange. Das Standardpacket (package standard) enthält die Definition des [[VHDL Glossar#character type]] -Typs, die ersten 128 Werte, die die ASCII-Zeichen repräsentieren. (§3.1.1, §14.2)

==== assertion violation ====
Zu dieser Verletzung kommt es, wenn die Bedingung einer assert-Anweisung mit "false" bewertet wird. (§8.2)

==== associated driver ====
Der einfache [[VHDL Glossar#driver]] für ein [[VHDL Glossar#signal]] innerhalb einer expliziten oder gleichwertigen Prozessanweisung, in welcher sich die Signalzuweisung befindet. (§12.6.1)

==== associated in whole ====
Falls ein einzelnes [[VHDL Glossar#association element]] eines zusammengesetzten Formalismus (composite [[VHDL Glossar#formal]] ) die Verbindung für den gesamten Formalismus darstellt. (§4.3.2.2)

==== associated individually ====
Die Eigenschaft eines [[VHDL Glossar#formal]] [[VHDL Glossar#port]] , eines [[VHDL Glossar#generic]] , oder der [[VHDL Glossar#parameter]] eines gemischten Typs ( [[VHDL Glossar#composite type]] ), welcher in einigen [[VHDL Glossar#association list]] erwartet wird. Ein gemischtet Formalismus ( formal ), dessen Vereinigung definiert wird über die Verbindung von mehrfachen [[VHDL Glossar#association element]] in einer einzelnen association list , wird als individuell verbunden in dieser Liste bezeichnet. Das Format solcher association element darf nur nicht überlappende [[VHDL Glossar#subelement]] oder Teile des Formalismusses ( formal ) beschreiben ( [[VHDL Glossar#denote]] ). (§4.3.2.2)

==== association element ====
Dieses Element verbindet ein [[VHDL Glossar#actual]] oder ein local mit einem local oder [[VHDL Glossar#formal]] . (§4.3.2.2)

==== association list ====
Diese Liste baut die Korrespondenz zwischen [[VHDL Glossar#formal]] oder [[VHDL Glossar#local port]] oder [[VHDL Glossar#parameter]] [[VHDL Glossar#name]] und local oder [[VHDL Glossar#actual]] name oder [[VHDL Glossar#expression]] auf. (§4.3.2.2)

==== attribute ====
Die Definition einiger Eigenschaften einer [[VHDL Glossar#named entity]] . Einige [[VHDL Glossar#attribute]] sind bereits vordefiniert für [[VHDL Glossar#type]] , [[VHDL Glossar#range]] , Werte, [[VHDL Glossar#signal]] und Funktionen. Die verbleibenden Eigenschaften werden als Konstanten ( [[VHDL Glossar#constant]] ) vom Benutzer definiert. (§4.4)

===== B =====
==== base specifier ====
Dieses Wortelement (lexical element) zeigt an, ob ein [[VHDL Glossar#bit string literal]] als ein binärer, oktaler oder hexadezimaler Wert interpretiert wird. (§13.7)

==== base type ====
[[VHDL Glossar#subtype]]s bauen auf diesem //Basistyp// auf und definieren eine Untermenge von möglichen Werten, die man auch als [[VHDL Glossar#constraint]] dieses Basistyps bezeichnet. Der //Basistyp// von einem [[VHDL Glossar#type]] ist der Typ selber. Der //Basistyp// eines subtype kann durch rekursives Untersuchen der Typkennzeichnung des subtype gefunden werden. (§3)

==== based literal ====
Ein //based literal// ist ein [[VHDL Glossar#abstract literal]] , das in einer Form dargestellt wird, die explizit eine Basis spezifiziert. Die Basis ist auf den Bereich ( [[VHDL Glossar#range]] ) 2 bis 16 beschränkt. (§13.4.2)

==== basic operation ====
Eine Operation die zu einer der folgenden Ausführungen paßt:
  - Eine Zuweisung (innerhalb einer Zuweisung oder Initialisierung);
  - Ein Verteiler ( [[VHDL Glossar#allocator]] );
  - Ein [[VHDL Glossar#selected name]] , ein Index- [[VHDL Glossar#name]] , oder ein [[VHDL Glossar#slice]] name ;
  - Eine Kennzeichnung (innerhalb eines kennzeichnenden [[VHDL Glossar#expression]] ), eine explizite [[VHDL Glossar#type conversion]] , ein [[VHDL Glossar#formal]] oder [[VHDL Glossar#actual]] [[VHDL Glossar#designator]] in Form einer type conversion , oder eine implizite type conversion eines Wertes der Menge [[VHDL Glossar#type]] [[VHDL Glossar#universal_integer]] oder [[VHDL Glossar#universal_real]] zu einem korrespondierenden Wert eines anderen [[VHDL Glossar#numeric type]] ;
  - Ein [[VHDL Glossar#numeric literal]] (für einen universellen [[VHDL Glossar#type]] ), der [[VHDL Glossar#literal]] "ungueltig" (für einen [[VHDL Glossar#access type]] ), ein [[VHDL Glossar#string literal]] , ein [[VHDL Glossar#bit string literal]] , ein [[VHDL Glossar#aggregate]] , oder ein vordefiniertes [[VHDL Glossar#attribute]] . (§3)

==== basic signal ====
Ein Signal ( [[VHDL Glossar#signal]] ), das die [[VHDL Glossar#driving value]] für alle anderen Signale bestimmt. Ein [[VHDL Glossar#basic signal]] ist:
  * Entweder ein skalares [[VHDL Glossar#signal]] oder ein [[VHDL Glossar#resolved signal]] ;
  * Kein [[VHDL Glossar#subelement]] eines resolved signal ;
  * Kein [[VHDL Glossar#implicit signal]] in der Form [[VHDL Glossar#attribute]] S'Stable(T), S'Quiet(T), or S'Transaction;
  * Kein implicit signal [[VHDL Glossar#guarded signal]] . (§12.6.2)

==== belong (to a range) ====
Die Eigenschaften eines Wertes bezüglich des möglichen [[VHDL Glossar#range]] . Der Wert V wird als //belong to a range// bezeichnet, falls die Unterschiede ( [[VHDL Glossar#lower bound]] <= V) und (V <= [[VHDL Glossar#upper bound]] ) beide richtig sind, wobei wie zu erwarten, lower bound und upper bound die Grenzen des Bereichs ( range ) darstellen. (§3.1, §3.2.1)

==== belong (to a subtype) ====
Die Eigenschaften eines Wertes die im Bereich eines [[VHDL Glossar#subtype]] liegen. Ein Wert wird als belong to a subtype eines vorgegebenen [[VHDL Glossar#type]] bezeichnet, falls er zu dem type gehört und die dazugehörigen Bedingungen ( [[VHDL Glossar#constraint]] ) erfüllt. (§3, §3.2.1)

==== binding ====
Der Vorgang einer Verbindung einer [[VHDL Glossar#design entity]] und die optionelle Verbindung einer [[VHDL Glossar#architecture body]] mit einer [[VHDL Glossar#instance]] einer Komponente. Ein //binding// kann explizit oder durch Anzeige einer Bindung mit Vorgabewerten spezifiziert werden. (§1.3, §5.2.1, §5.2.2, §12.3.2.2, §12.4.3)

==== bit string literal ====
Dieses [[VHDL Glossar#literal]] , wird durch eine Folge von [[VHDL Glossar#extended digit]] zusammengesetzt, die zwischen zwei Anführungsstrichen eingeschlossen werden und mit einer Basisangabe beginnen ( [[VHDL Glossar#base specifier]] . Der [[VHDL Glossar#type]] eines bit string literal ist abhängig vom Kontext. (§7.3.1, §13.7)

==== block ====
Ein Block repräsentiert einen Teil der Designhierarchie. Es gibt entweder externe oder interne Blöcke ( [[VHDL Glossar#external block]] or [[VHDL Glossar#internal block]] ). (§1, §1.1.1.1, §1.1.1.2, §1.2.1, §1.3, §1.3.1, §1.3.2)

==== bound ====
Ein Label wird als //bound// bezeichnet, wenn es in der Instantziierungsliste der [[VHDL Glossar#configuration]] [[VHDL Glossar#specification]] festgelegt wird. (§5.2)

==== box ====
Das Symbol <> in einer [[VHDL Glossar#index subtype]] -Definition, welche für einen nicht festgelegte Bereich ( [[VHDL Glossar#range]] ) steht. Verschiedene Objekte ( [[VHDL Glossar#object]] ) eines Typs ( [[VHDL Glossar#type]] ) können verschiedene Grenzen ( [[VHDL Glossar#bound]] ) und Richtungen haben. (§3.2.1)

==== bus ====
Eine Art eines [[VHDL Glossar#guarded signal]] . Ein Bus erreicht einen benutzerspezifischen Wert falls alle seiner Treiber ( [[VHDL Glossar#driver]] ) abgeschaltet sind. (§4.3.1.2, §4.3.2)

===== C =====
==== character literal ====
Ein [[VHDL Glossar#literal]] des [[VHDL Glossar#character type]] . //Character literals// zeichnen sich dadurch aus, das einer der graphic characters (inklusive der space und der nonbreaking space characters) zwischen zwei Apostrophen (') eingeschlossen wird. (§13.2, §13.5)

==== character type ====
Ein [[VHDL Glossar#enumeration type]] mit wenigsten einem [[VHDL Glossar#character literal]] zwischen den [[VHDL Glossar#enumeration literal]] . (§3.1.1, §3.1.1.1)

==== closely related types ====
Das sind zwei Typen ( [[VHDL Glossar#type]] ), die den selben Typ oder zwei numerische Typen bezeichnen ( [[VHDL Glossar#numeric type]] ). Zwei [[VHDL Glossar#array type]] werden ebenfalls //closely related// bezeichnet, falls sie die gleiche Dimension besitzen, falls ihr index type auf jeder Position //closely related// ist und falls die array type den gleichen Elementtyp besitzen. Explizite [[VHDL Glossar#type conversion]] ist nur zwischen closely related types erlaubt. (§7.3.5)

==== complete ====
Eine Schleife, die am Ende ihrer Ausführung ist. Genauso ist der Wiederholungslauf einer Schleife komplett ( //complete// ), falls die Bedingung einer while-Schleife "falsch" ist oder alle Werte innerhalb des diskreten Bereichs ( [[VHDL Glossar#discrete range]] ) einer For-Schleife einem Wiederholungs [[VHDL Glossar#parameter]] (iteration parameter ) zugewiesen wurden. (§8.9)

==== complete context ====
Eine [[VHDL Glossar#declaration]] , eine [[VHDL Glossar#specification]] , oder eine Anweisung. //Complete contexts// werden bei Überladevorgängen verwendet. (§10.5)

==== composite type ====
Ein Typ ( [[VHDL Glossar#type]] ) dessen Werte aus Elementen besteht. Es gibt zwei verschieden Klassen von //composite types// : [[VHDL Glossar#array type]] und [[VHDL Glossar#record type]] . (§3, §3.2)

==== concurrent statement ====
Eine Anweisung, ohne einen definierten relativen Befehl, die asynchron ausgeführt wird ( [[VHDL Glossar#execute]] ). Nebenläufige Anweisungen ( //concurrent statements// ) werden für die Darstellung von Datenflüssen und strukturellen Beschreibungen eingesetzt. (§9)

==== configuration ====
Dieses Konstrukt definiert, wie die [[VHDL Glossar#instance]] einer Komponente in einem gegeben [[VHDL Glossar#block]] an die [[VHDL Glossar#design entity]] angebunden ( [[VHDL Glossar#bound]] ) werden. In einer //configuration// wird definiert, auf welchen Weise die design entity zu einem kompletten Design verbunden werden. (§1, §1.3. 5.2)

==== conform ====
Zwei [[VHDL Glossar#subprogram specification]] , werden als //conform// gekennzeichnet, falls, abgesehen von verschiedenen erlaubten Minimalversionen,sich beide [[VHDL Glossar#specification]] durch die selbe Folge von lexikalischen Elementen zusammensetzen und korrespondierende lexikalische Elemente sichtbar die gleiche Funktion besitzen. Konformität wird ähnlich für [[VHDL Glossar#deferred constant]] [[VHDL Glossar#declaration]] definiert. (§2.7)

==== connected ====
Ein formeller Ein-/Ausgang ( [[VHDL Glossar#formal]] [[VHDL Glossar#port]] ), der mit einem [[VHDL Glossar#actual]] port oder [[VHDL Glossar#signal]] verbunden ist, gilt als //connected// . Ein formal port , der mit dem reservierten Wort open verbunden ist, gilt als //unconnected// . (§1.1.1.2)

==== constant ====
Ein [[VHDL Glossar#object]] dessen Wert sich nicht ändert ist ein Konstante. Konstanten dürfen explizit als [[VHDL Glossar#subelement]] von [[VHDL Glossar#explicitly declared constant]] , oder Interface //constants// deklariert werden. Konstanten, die in packages festgelegt werden, können auch [[VHDL Glossar#deferred constant]] sein. (§4.3.1.1)

==== constraint ====
//Constraints// sind eine Untermenge von Typwerten (values of a [[VHDL Glossar#type]] ). Die Menge der möglichen Werte eines Objekts ( [[VHDL Glossar#object]] ) eines Typs ( type ) können einer Bedingung unterliegen die als //constraint// bezeichnet wird. Ein Wert genügt (satisfy) einem constraint , falls er die entsprechenden Bedingungen erfüllt. Es gibt [[VHDL Glossar#index constraint]] , [[VHDL Glossar#range constraint]] und size- constraint . (§3)

==== conversion function ====
Eine Funktion die zur Konvertierung von Werten dient. Für Interface- [[VHDL Glossar#object]] der Art ( [[VHDL Glossar#mode]] ) in sind //conversion functions// nur für [[VHDL Glossar#actual]] erlaubt. Für Interface- object der Art out oder buffer sind //conversion functions// für [[VHDL Glossar#formal]] erlaubt. Für Interface- object der Art inout oder linkage sind conversion functions nur für formal und actual zusammen erlaubt. Conversion functions besitzen einen einzigen [[VHDL Glossar#parameter]] . Eine //conversion function// verbunden mit einem actual akzeptiert den Typ des actual und gibt den Typ des formal zurück. Eine conversion function verbunden mit einem formal nimmt auch den Typ des formal und antwortet mit dem Typ des actual . (§4.3.2.2)

==== convertible ====
Eine Operandeneigenschaft, die in Beziehung zu irgendeinem Typ ( [[VHDL Glossar#type]] ) steht. Ein Operand ist //convertible// zu irgendeinem Typen , falls eine implizierte Konvertierung zu diesem Typ besteht. (§7.3.5)

==== current value ====
Der Teilwert einer einzelnen Wertveränderung ( [[VHDL Glossar#transaction]] ) eines Treibers, dessen Zeitkomponente nicht grösser ist als die momentane Simulationszeit.  (§12.6. 12.6.1, §12.6.2, §12.6.3)

===== D =====
==== decimal literal ====
Ein [[VHDL Glossar#abstract literal]] welcher in dezimaler Notation dargestellt wird. Die Basis des [[VHDL Glossar#literal]] ist implizit 10. Das literal darf je nach Wahl einen Exponenten, einen Dezimalpunkt oder einen Bruchteil einbinden. (§13.4.1)

==== declaration ====
Eine //declaration// ist ein Konstrukt, welches eine [[VHDL Glossar#entity declaration]] definiert und ein Namen (oder eine irgendeine andere Notation) damit verbindet. Diese Verbindung steht im Zusammenhang mit einem Textbereich der als Deklarationsbereich ( [[VHDL Glossar#scope]] of the [[VHDL Glossar#declaration]] ) benannt wird. Innerhalb des scope existieren Räume, in denen es möglich ist Kennzeichen einzusetzen, um Bezug zu nehmen auf die mit ihnen verbundene entity declaration ; an solchen Stellen wird das Kennzeichen als [[VHDL Glossar#simple name]] der [[VHDL Glossar#named entity]] bezeichnet. Man sagt der simple name beschreibt die verbundende named entity . (§4)

==== declarative part ====
Ein syntaktischer Bestandteil verschiedener [[VHDL Glossar#declaration]] oder Darstellungen (wie [[VHDL Glossar#entity declaration]] , [[VHDL Glossar#architecture body]] , und [[VHDL Glossar#block]] -Darstellungen). Der Deklarationsteil definiert den lexikalischen Bereich (üblicherweise beginnend mit einem Schlüsselwort - z.B. "is"- und endend mit einem anderem Schlüsselwort z.B. "begin") in dem die declaration liegen können. (§1.1.2, §1.2.1, §1.3, §2.6, §9.1, §9.2, §9.6.1, §9.6.2)

==== declarative region ====
Ein semantischer Bestandteil von verschiedenen [[VHDL Glossar#declaration]] oder Darstellungen. Eine //declarative region// zerlegt Bereiche, wie die //declarative region// einer [[VHDL Glossar#entity declaration]] , welche sich bis zum Ende eines jeden [[VHDL Glossar#architecture body]] für diese entity ausdehnt ( [[VHDL Glossar#extend]] ) . (§10.1)

==== decorate ====
Decorate bedeutet die Verbindung eines benutzerdefinierten [[VHDL Glossar#attribute]] mit einer [[VHDL Glossar#named entity]] und die Definition des Wertes von dem attribute . (§5.1)

==== default expression ====
Eine Voreinstellung die für einen [[VHDL Glossar#formal]] [[VHDL Glossar#generic]] , einen [[VHDL Glossar#port]] , oder einen [[VHDL Glossar#parameter]] benötigt wird, falls das Interface- [[VHDL Glossar#object]] unverbunden ist. Eine Voreinstellung- [[VHDL Glossar#expression]] wird ebenso verwendet um einen Initialwert für [[VHDL Glossar#signal]] und die dazugehörigen Treiber zu unterstützen. (§4.3.1.2, §4.3.2.2)

==== deferred constant ====
Eine [[VHDL Glossar#constant]] , die ohne ein Zuweisungssymbol <nowiki>(:=)</nowiki> und einer [[VHDL Glossar#expression]] in einer package [[VHDL Glossar#declaration]] festgelegt wurde, wird als //deferred constant// bezeichnet. Eine verbundene [[VHDL Glossar#full declaration]] der Konstante muss im //package body// zur Definition des Wertes der Konstante festgelegt sein. (§4.3.1.1)

==== delta cycle ====
Ein [[VHDL Glossar#simulation cycle]] in dem die Simulationszeit von Beginn bis Ende des Zyklusses die gleiche ist, ist ein //delta cycle// . Das heisst innerhalb eines Deltazyklusses schreitet die Simulationszeit nicht voran. Nur [[VHDL Glossar#nonpostponed process]] können während eines Deltazyklusses ausgeführt ( [[VHDL Glossar#execute]] ) werden. (§12.6.4)

==== denote ====
Die Eigenschaft des Identifizierungsmerkmals die in einer [[VHDL Glossar#declaration]] angegeben wird. Dort wo die declaration sichtbar ( [[VHDL Glossar#visible]] ) ist, sagt man, daß dieses in der declaration angegebene Merkmal die [[VHDL Glossar#named entity]] , die in der declaration festgelegt wird, beschreibt ( //denote// ). (§4)

==== depend (on a library unit) ====
Eine [[VHDL Glossar#design unit]] die explizit oder implizit andere [[VHDL Glossar#library unit]] im Fall des Gebrauchs angibt. Diese Abhängigkeit beeinträchtigt die möglichen Anweisungen zur Analyse ( [[VHDL Glossar#analysis]] ) der design unit . (§11.4)

==== depend (on a signal value) ====
Eine Eigenschaft eines [[VHDL Glossar#implicit signal]] welche irgendeinem anderen [[VHDL Glossar#signal]] abhängig ist. Der momentane Wert ( [[VHDL Glossar#current value]] ) eines implicit signal R ist abhängig vom momentanen Wert ( current value ) eines anderen signal S, falls R ein implicit signal S'Stable(T), S'Quiet(T), oder S'Transaction beschreibt ( [[VHDL Glossar#denote]] ), oder falls R ein implizites GUARD signal beschreibt und S ist irgendein anderes implicit signal , welches innerhalb der [[VHDL Glossar#guard expression]] , die den current value von R festlegt, benannt wird. (§12.6.3)

==== descending range ====
Ein Bereich ( [[VHDL Glossar#range]] ) L downto R. (§3.1)

==== design entity ====
Eine //design entity// ist eine [[VHDL Glossar#entity declaration]] mit einem dazugehörigen [[VHDL Glossar#architecture body]] . Verschiedene //design enitities// können die gleiche entity declaration benutzen. In diesem Fall beschreiben sie verschiedene Komponenten mit der gleichen Schnittstelle oder die gleiche Komponente aus einer anderen Perspektive. (§1)

==== design file ====
Eine oder mehrere [[VHDL Glossar#design unit]] in Folge. (§1.1)

==== design hierarchy ====
Die komplette Darstellung eines Designs, die aus der aufeinanderfolgenden Auflösung einer [[VHDL Glossar#design entity]] in Unterkomponenten und der Verbindung ( [[VHDL Glossar#binding]] ) dieser Bestandteile mit anderen design entity , die auf die gleiche Weise bearbeitet werden, zustande kommt. (§1)

==== design library ====
Eine host-abhängige Einrichtung zum Speichern von zwischenzeitliche Darstellungen der analysierten [[VHDL Glossar#design unit]] . (§11.2)

==== design unit ====
Ein Konstrukt, welches unabhängig analysiert werden kann und in einer [[VHDL Glossar#design library]] abgelegt wird. Eine design unit kann eine [[VHDL Glossar#entity declaration]] sein, ein [[VHDL Glossar#architecture body]] , eine [[VHDL Glossar#configuration]] [[VHDL Glossar#declaration]] , ein package declaration , oder eine package body declaration . (§11.1)

==== designate ====
Eine Eigenschaft eines [[VHDL Glossar#access value]] der den Wert an einige [[VHDL Glossar#object]] übergibt, falls der access value ungleich Null ist. Man sagt ein access value ungleich Null bestimmt (to designate) ein object . (§3.3)

==== designated subtype ====
Ein //designated subtype// ist für einen [[VHDL Glossar#access type]] der [[VHDL Glossar#subtype]] der durch die subtype -Kennzeichen der access type -Definition festgelegt wird. (§3.3)

==== designated type ====
Der designated type ist für einen [[VHDL Glossar#access type]] der [[VHDL Glossar#base type]] des [[VHDL Glossar#subtype]] , der durch die subtype -Kennzeichen der access type -Definition festgelegt wird. (§3.3)

==== designator ====
  - Ein //designator// ist die erste Syntax, die einen Teil eines [[VHDL Glossar#association element]] bildet. Ein [[VHDL Glossar#formal]] //designator// spezifiziert welcher formal [[VHDL Glossar#parameter]] , welcher [[VHDL Glossar#port]] , oder welches [[VHDL Glossar#generic]] (oder welches [[VHDL Glossar#subelement]] oder [[VHDL Glossar#slice]] eines parameter , eines port , oder eines generic ) mit einem [[VHDL Glossar#actual]] über ein vorgegebenes association element verbunden werden muss. Ein actual designator spezifiziert welche actual [[VHDL Glossar#expression]] , welches [[VHDL Glossar#signal]] , oder welche [[VHDL Glossar#variable]] mit einem formal (oder einem subelement oder mehreren subelement s eines formal ) verbunden werden muss. Ein actual designator kann auch festlegen, daß der formal in dem vorgegebenen association element ohne Verbindung bleibt (mit Hilfe eines actual designators der Klasse open). (§4.3.2.2)
  - Ein Kennzeichen, [[VHDL Glossar#character literal]] , oder ein Operator-Symbol welcher ein [[VHDL Glossar#alias]] für irgendwelche anderen [[VHDL Glossar#name]] definiert. (§4.3.3)
  - Ein [[VHDL Glossar#simple name]] welcher ein vordefiniertes oder anwenderdefiniertes [[VHDL Glossar#attribute]] in einem attribute name , oder ein anwenderdefiniertes attribute in einer attribute [[VHDL Glossar#specification]] beschreibt. (§5.1, §6.6)
  - Ein simple name , character literal , oder ein operator symbol , und möglicherweise eine Signatur, die eine [[VHDL Glossar#named entity]] in der entity name -Liste einer attribute specification beschreibt. (§5.1)
  - Das Symbol eines Kennzeichens oder eines Operators, das den name eines Unterprogramms festlegt. (§2.1)

==== directly visible ====
Eine [[VHDL Glossar#visible]] [[VHDL Glossar#declaration]] , die bei der Auswahl nicht visible (sichtbar) ist. Eine declaration ist //directly visible// innerhalb ihrer [[VHDL Glossar#immediate scope]] . Davon sind alle Plätze ausgeschlossen, an denen die declaration versteckt ist (is [[VHDL Glossar#hidden]] ). Eine declaration die [[VHDL Glossar#immediately within]] (unmittelbar innerhalb) dem visible Teil eines Package auftritt, kann über ein bestimmtes Hilfsmittel //directly visible// gemacht werden. (§10.3, 10.4)

==== discrete array ====
Ein eindimensionales Feld, das sich aus Elementen des [[VHDL Glossar#discrete type]] zusammensetzt. (§7.2.3)

==== discrete range ====
Ein Bereich ( [[VHDL Glossar#range]] ), dessen Grenzen ( [[VHDL Glossar#bound]] ) von Elementen des [[VHDL Glossar#discrete type]] gebildet werden. (§3.2.1, §3.2.1.1)

==== discrete type ====
Ein [[VHDL Glossar#enumeration type]] oder ein [[VHDL Glossar#integer type]] . Jeder Wert eines //discrete type// hat die einen Integerwert als Positionsnummer. Index-Anweisungen und Wiederholungen gebrauchen die Werte des discrete types . (§3.1)

==== driver ====
Ein //driver// enthält die [[VHDL Glossar#projected output waveform]] eines [[VHDL Glossar#signal]] . Der Wert des signal ist eine Funktion der momentante Werte ( [[VHDL Glossar#current value]] ) seiner Treiber ( //drivers// ). Jeder Prozess der auf ein gegebenes Signal weist, enthält implizit einen Treiber für das signal . Eine signal -Zuweisung wirkt nur auf den (die) [[VHDL Glossar#associated driver]] (s). (§12.4.4, §12.6.1, §12.6.2, §12.6.3)

==== driving value ====
Der Wert den ein [[VHDL Glossar#signal]] als eine Quelle ( [[VHDL Glossar#source]] ) anderer signal liefert. (§12.6.2)

===== E =====
==== effective value ====
Der effektive Wert ist der Wert, den man erhält bei der Auswertung eines Verweises ( [[VHDL Glossar#reference]] ) auf das [[VHDL Glossar#signal]] innerhalb eines Ausdrucks ( [[VHDL Glossar#expression]] ). (§12.6.2)

==== elaboration ====
Der Prozess bei welchem eine [[VHDL Glossar#declaration]] das Ergebnis vollendet. Vor der Fertistellung der //elaboration// (das heißt auch vor der //elaboration// ) ist eine declaration noch nicht ausgearbeitet. (§12)

==== element ====
Ein wesentlicher Bestandteil eines gemischten Typs ( [[VHDL Glossar#composite type]] ). (§3)

==== entity declaration ====
Die Definition der Schnittstelle zwischen einer vorgegebene [[VHDL Glossar#design entity]] und der Umgebung in welcher sie verwendet wird. Eine //entity declaration// kann auch [[VHDL Glossar#declaration]] und Anweisungen spezifizieren, die Teil einer design entity sind. Eine vorgegebene //entity declaration// kann von vielen design entity gleichzeitig benutzt werden, obwohl jede eine unterschiedliche [[VHDL Glossar#architecture body]] besitzt. Auf diese Weise kann eine //entity declaration// möglicherweise eine Klasse von design entities representieren, allerdings jede mit der gleichen Schnittstelle. (§1, §1.1)

==== enumeration literal ====
Ein [[VHDL Glossar#literal]] eines [[VHDL Glossar#enumeration type]] . Ein //enumeration literal// kann entweder ein Identifizierungkennzeichen oder ein [[VHDL Glossar#character literal]] sein. (§5.1.1, §7.3.1)

==== enumeration type ====
Ein Typ ( [[VHDL Glossar#type]] ), dessen Werte durch Aufzählung (enumerating) festgelegt werden. Die Werte dieses Typen werden durch [[VHDL Glossar#enumeration literal]] dargestellt. (§3.1, §3.1.1)

==== error ====
Ein in dieser Form nicht erlaubter Quelltext. Falls ein //error// während der [[VHDL Glossar#analysis]] einer [[VHDL Glossar#design unit]] angezeigt wird, wird die Erstellung einer [[VHDL Glossar#library unit]] für die gegebene design unit verhindert (pr //events// ). Ein //error// während der Laufzeit beendet eine Simulation. (§11.4)

==== erroneous ====
Eine [[VHDL Glossar#error]] -Bedingung die nicht immer erkannt wird. (§2.1.1.1, §2.2)

==== event ====
Ein Wechsel im momentanen Wert ( [[VHDL Glossar#current value]] ) eines Signals ( [[VHDL Glossar#signal]] ), welcher auftritt, falls ein signal mit seinem [[VHDL Glossar#effective value]] aktualisiert wird. (§12.6.2)

==== execute ====
  - Falls erst die [[VHDL Glossar#design hierarchy]] eines [[VHDL Glossar#model]] ausgearbeitet wird, wird dessen Netzwerk ( [[VHDL Glossar#net]] ) initialisiert und in einer abschließenden Simulation mit sich wiederholenden [[VHDL Glossar#simulation cycle]] weitergeführt. In diesen Simulationszyklen werden die Prozesse ausgeführt ( //executed// ) und das Netzwerk ( net ) wird aktualisiert ( [[VHDL Glossar#update]] ).
  - Falls ein Prozess die Aktionen ausführt, die in den Algorithmen des Befehlsteils festgelegt sind. (§12, 12.6)

==== expanded name ====
Ein ausgewählter Name ( [[VHDL Glossar#selected name]] - im syntaktischen Sinne) der ein oder alle [[VHDL Glossar#primary]] units in einer [[VHDL Glossar#library]] oder irgendeiner [[VHDL Glossar#named entity]] innerhalb einer primary unit beschreibt ( [[VHDL Glossar#denote]] ). (§6.3, §8.1)

==== explicit ancestor ====
Der "Elternteil" ( [[VHDL Glossar#parent]] ) des [[VHDL Glossar#implicit signal]] , welches über die vordefinierten [[VHDL Glossar#attribute]] 'DELAYED, 'QUIET, 'STABLE, oder 'TRANSACTION festgelegt wird. Die Verwendung der Vorsilbe des Attributs ( attribute ) wird festgelegt. Falls eine Vorsilbe ein [[VHDL Glossar#explicit signal]] (oder einen [[VHDL Glossar#member]] davon) beschreibt ( [[VHDL Glossar#denote]] ), dann ist das der explicit ancestor (Vorfahr) des implicit signal . Falls die Vorsilbe eines der implicit signal ist, die durch die vordefinierten attribute 'DELAYED, 'QUIET, 'STABLE, oder 'TRANSACTION festgelegt werden, ist diese Regel praktisch rekursiv. Falls die Vorsilbe ein implicit signal GUARD ist, hat das [[VHDL Glossar#signal]] keinen expliziten Vorfahren (explicit ancestor). (§2.2)

==== explicit signal ====
Ein [[VHDL Glossar#signal]] das durch die vordefinierten [[VHDL Glossar#attribute]] 'DELAYED, 'QUIET, 'STABLE, oder 'TRANSACTION festgelegt wird. (§2.2)

==== explicitly declared constant ====
Eine Konstante ( [[VHDL Glossar#constant]] ) eines spezifizierten Typs ( [[VHDL Glossar#type]] ), die über eine constant [[VHDL Glossar#declaration]] bestimmt wird. (§4.3.1.1)

==== explicitly declared object ====
Ein [[VHDL Glossar#object]] eines spezifizierten Typs ( [[VHDL Glossar#type]] ), welches über eine object [[VHDL Glossar#declaration]] festgelegt wird. Eine object declaration wird als [[VHDL Glossar#single-object declaration]] bezeichnet, falls deren Kennzeichenliste nur ein einziges Kennzeichen enthält; im anderen Fall spricht man von einer multiple- object declaration . (§4.3, §4.3.1)

==== expression ====
Ein Ausdruck der eine Wertberechnung festlegt. (§7.1)

==== extend ====
Eine Eigenschaft des Quelltextes, die eine [[VHDL Glossar#declarative region]] mit nicht zusammenhängenden Teilen bildet. Falls in einer declarative region mit getrennten Teilen ein Stück des Textes als //extend// von einigen bestimmten Punkten einer declarative region bis zum Ende dieser Zone bezeichnet wird, dann ist dieses Bruchstück die korrespondierende Untermenge der declarative region (dabei unterbricht dieses Bruchstück nicht die deklarierenden Elemente zwischen der Schnittstellen- [[VHDL Glossar#declaration]] und der korrespondierenden Hauptteil- declaration ). (§10.1)

==== extended digit ====
Ein lexikalisches Element, das entweder eine Zahl oder ein Buchstabe ist. (Erweiterte Zeichenmenge!) (§13.4.2)

==== external block ====
Eine //top-level// [[VHDL Glossar#design entity]] , die in einer [[VHDL Glossar#library]] liegt und als Teilkomponente in anderen Designs eingesetzt werden kann. (§1)

===== F =====
==== file type ====
Ein Typ ( [[VHDL Glossar#type]] ), der den Zugriff auf [[VHDL Glossar#object]] unterstützt, die eine Folge von Werten eines vorgegebenen type enthalten. File type werden normalerweise in einer host-Systemumgebung verwendet. Der Wert eines Datei- object ist die Folge von Werten, die in der host-Systemdatei enthalten sind. (§3, §3.4)

==== floating point types ====
Ein diskreter [[VHDL Glossar#scalar type]] , dessen Werte reelle Zahlen annähern. Die Darstellung eines //floating point types// hat eine Minimalgenauigkeit von sechs dezimalen Stellen. (§3.1, §3.1.4)

==== foreign subprogram ====
Ein Unterprogramm das mit dem [[VHDL Glossar#attribute]] 'FOREIGN ausgestattet und in dem package STANDARD definiert wird. Die Zeichenfolge des attribute kann dabei die Implementierung betreffende Informationen über das Unterprogramm spezifizieren. //Foreign subprograms// dürfen keine VHDL-Anwendungen enthalten. Eine Anwendung kann Einschränkungen hinsichtlich der erlaubten [[VHDL Glossar#mode]] , classes und [[VHDL Glossar#type]] der [[VHDL Glossar#formal]] [[VHDL Glossar#parameter]] für ein //foreign subprogram// festlegen. Dazu gehören [[VHDL Glossar#constraint]] auf die Zahl und die erlaubten Zugriffsweisen der parameter . (§2.2)

==== formal ====
Ein //formal// [[VHDL Glossar#port]] oder //formal// [[VHDL Glossar#generic]] einer [[VHDL Glossar#design entity]] , eine [[VHDL Glossar#block]] -Anweisung oder ein //formal// [[VHDL Glossar#parameter]] eines Unterprogramms. (§2.1.1, §4.3.2.2, §5.2.1.2, §9.1)

==== full declaration ====
Eine [[VHDL Glossar#constant]] [[VHDL Glossar#declaration]] , die innerhalb eines package body mit den selben Kennzeichen auftritt, wie eine [[VHDL Glossar#deferred constant]] declaration in der korrespondierenden package declaration . Eine full [[VHDL Glossar#type]] declaration ist eine type declaration die mit einer [[VHDL Glossar#incomplete type declaration]] verbunden ist. (§2.6)

==== fully bound ====
Eine [[VHDL Glossar#binding]] -Kennzeichnung für die Komponente [[VHDL Glossar#instance]] , die eine entity-(Schnittstelle) und eine [[VHDL Glossar#architecture body]] mit einschließt. (§5.2.1.1)

===== G =====
==== generate parameter ====
Ein [[VHDL Glossar#constant]] [[VHDL Glossar#object]] dessen [[VHDL Glossar#type]] der [[VHDL Glossar#base type]] der [[VHDL Glossar#discrete range]] einer generierten [[VHDL Glossar#parameter]] [[VHDL Glossar#specification]] ist. Ein generate parameter wird mit einer generate-Anweisung festgelegt. (§9.7)

==== generic ====
Eine Schnittstellen- [[VHDL Glossar#constant]] , die in einer [[VHDL Glossar#block]] -Überschrift einer block -Anweisung, einer Komponenten- [[VHDL Glossar#declaration]] oder einer [[VHDL Glossar#entity declaration]] festgelegt wird. Generics unterstützen einen Kanal für statische ( [[VHDL Glossar#static]] ) Informationen, die zu einem block der eigenen Umgebung weitergeleitet werden. Anders dagegen constant , der Wert eines generic kann dennoch extern geliefert werden und zwar entweder innerhalb einer Komponenteninstanziierung oder innerhalb einer [[VHDL Glossar#configuration]] [[VHDL Glossar#specification]]. (§1.1.1.1)

==== generic interface list ====
Alle Listen die lokale oder [[VHDL Glossar#formal]] [[VHDL Glossar#generic]] [[VHDL Glossar#constant]] definieren. (§1.1.1.1, §4.3.2.1)

==== globally static expression ====
Ein Ausdruck ( [[VHDL Glossar#expression]] ), der ausgewertet werden kann, sobald die [[VHDL Glossar#design hierarchy]] , innerhalb der er sich befindet, abgearbeitet wird. Eine [[VHDL Glossar#locally static expression]] ist ebenfalls global [[VHDL Glossar#static]] , bis die expression in einem dynamisch ausgeführten Kontext erscheint. (§7.4)

==== globally static primary ====
Ein [[VHDL Glossar#primary]] , dessen Wert während der [[VHDL Glossar#elaboration]] seines [[VHDL Glossar#complete context]] bestimmt werden kann und der sich danach nicht mehr ändern darf. Globale statische ( [[VHDL Glossar#static]] ) primaries können nur innerhalb statisch ausgeführter Zusammenhänge auftreten. (§7.4.2)

==== group ====
Eine name Auswahl von [[VHDL Glossar#name]] entities. Durch Groups werden Informationen, die nicht durch die Sprache spezifizierten sind, zwischen verschiedenen name entities ausgetauscht. Groups können im Detail mit [[VHDL Glossar#attribute]] versehen sein. (§4.6, §4.7)

==== guard ====
//Siehe// [[VHDL Glossar#guard expression]].

==== guard expression ====
Eine Boolean-Ausdruck ( [[VHDL Glossar#expression]] ), der mit einer [[VHDL Glossar#block]] -Anweisung verbunden ist. Diese Anweisung steuert die Zuweisungen zu [[VHDL Glossar#guarded signal]] innerhalb des block . Eine guard expression definiert ein [[VHDL Glossar#implicit signal]] GUARD, das zur Steuerung der Ausführungen von verschiedenen Anweisungen innerhalb des block dienen kann. (§4.3.1.2, §9.1, §9.5)

==== guarded assignment ====
Eine simultane [[VHDL Glossar#signal]] -Zuweisung, die die Option geschützt einschließt und festlegt, daß die signal -Zuweisung ausgeführt ( [[VHDL Glossar#execute]] ) wird, wenn ein signal GUARD vom Zustand FALSE in den Zustand TRUE wechselt, oder wenn das signal den Zustand TRUE hat und ein [[VHDL Glossar#event]] auf einem der signal [[VHDL Glossar#reference]] in einem der dazugehörigen [[VHDL Glossar#guard expression]] eintritt. Das signal GUARD kann eines der implizit deklarierten und mit [[VHDL Glossar#block]] Anweisungen verbundenen GUARD signal associated with block statements that have guard expression , or it may be an explicitly declared signal of [[VHDL Glossar#type]] Boolean that is [[VHDL Glossar#visible]] at the point of the concurrent signal assignment statement. (§9.5)

==== guarded signal ====
Ein [[VHDL Glossar#signal]] das als [[VHDL Glossar#register]] oder [[VHDL Glossar#bus]] deklariert wird. Solche signal haben eine spezielle Semantic, falls ihre Treiber aktualisiert werden ( [[VHDL Glossar#update]] ) innerhalb geschützter (guarded) signal -Zuweisungen. (§4.3.1.2)

==== guarded target ====
Der Zielbereich einer [[VHDL Glossar#signal]] Zuweisung, der nur aus [[VHDL Glossar#guarded signal]] bestehen darf. Ein ungeschützter Zielbereich besteht nur aus un guarded signal (ungeschützten Signalen ).  (§9.5)

===== H =====
==== hidden ====
Eine [[VHDL Glossar#declaration]] , die nicht direkt sichtbar ( [[VHDL Glossar#directly visible]] ) ist. Eine declaration kann in ihrem Bereich ( [[VHDL Glossar#scope]] ) durch einen [[VHDL Glossar#homograph]] der declaration versteckt ( hidden ) sein.  (§10.3)

==== homograph ====
Eine reflexive Eigenschaft zweier [[VHDL Glossar#declaration]] . Jede der beiden declaration wird als homograph zu der anderen bezeichnet, falls beide declaration das gleiche Identifizierungskennzeichen besitzen und ein Überladen der einen über die andere erlaubt ist. Falls das Überladen für beide erlaubt ist, dann ist jede der beiden declaration homograph zu der anderen, falls sie das gleiche Identifizierungskennzeichen, Ausführungssymbol oder [[VHDL Glossar#character literal]] besitzen, ebenso wie den gleichen [[VHDL Glossar#parameter and result type profile]] und Typen profil. (§1.3.1, §10.3)

===== I =====
==== identify ====
Eine Eigenschaft eines [[VHDL Glossar#name]] , die in Form eines [[VHDL Glossar#aggregate]] innerhalb der Elementverbindung eines Signalzuweisungsbereichs erscheint. Der name sagt man, kennzeichnet ein [[VHDL Glossar#signal]] oder eine [[VHDL Glossar#variable]] und irgendein [[VHDL Glossar#subelement]] dieses signal oder dieser variable . (§8.4, §8.5)

==== immediate scope ====
Die Eigenschaft einer [[VHDL Glossar#declaration]] die in der [[VHDL Glossar#declarative region]] erwartet wird, in dem die declaration unmittelbar auftritt. Der unmittelbare Bereich ( //immediate scope// ) einer declaration hängt ( [[VHDL Glossar#extend]] ) von dem Anfang der declaration bis zum Ende der declarative region ab. (§10.2)

==== immediately within ====
Die Eigenschaft einer [[VHDL Glossar#declaration]] die innerhalb irgendeiner [[VHDL Glossar#declarative region]] erwartet wird. Eine declaration sagt man, erscheint unmittelbar ( immediately within ) inerhalb einer declarative region , falls dies Region ider innerste Bereich ist, der die declaration eischließt. Dabei zählt nicht die declarative region (falls eine existiert), die mit der Deklaration selber verbunden ist. (§10.1)

==== implicit signal ====
Irgendein [[VHDL Glossar#signal]] S'Stable(T), S'Quiet(T), S'Delayed, oder S'Transaction, oder irgendein implizites GUARD signal . Ein Mitglied ( [[VHDL Glossar#member]] ) eines //implicit signal// ist ebenfalls ein //implicit signal// . (§12.6.2,§12.6.3, §12.6.4)

==== implicitly declared object ====
Ein [[VHDL Glossar#object]] dessen [[VHDL Glossar#declaration]] nicht explizit innerhalb des Quelltextest, aber das Ergebnis anderer Konstrukte ist; z.B. das [[VHDL Glossar#signal]] GUARD. (§4.3, §9.1, §14.1)

==== imply ====
Die Eigenschaft einer [[VHDL Glossar#binding]] eines Kennzeichens in einer [[VHDL Glossar#configuration]] [[VHDL Glossar#specification]] mit Blick auf die [[VHDL Glossar#design entity]] , die durch die binding specification gekennzeichnet wird. Man sagt, die binding indication impliziert die design entity ; die design entity kann direkt, indirekt oder durch die Vorgabe angezeigt werden. (§5.2.1.1)

==== impure function ====
Eine Funktion, die immer, wenn sie aufgerufen wird, einen einen anderen Wert liefert, selbst wenn die verschiedenen Aufrufe mit übereinstimmenden [[VHDL Glossar#parameter]] erfolgen. Eine echte Funktion ( [[VHDL Glossar#pure function]] ) liefert immer den gleichen Wert, wenn die aktuellen Parameter n ( [[VHDL Glossar#actual]] parameter ) übereinstimmen. Eine unechte Funktion ( //impure function// ) kann Objekte ( [[VHDL Glossar#object]] ) auch außerhalb ihres vorgegebenen Bereichs ( [[VHDL Glossar#scope]] ) aktualisieren. Sie kann ein größere Klasse an Werten erzeugen als eine echte Funktion ( pure function ). (§2)

==== incomplete type declaration ====
Eine [[VHDL Glossar#type]] [[VHDL Glossar#declaration]] die benutzt wird, um gegenseitig abhängige und rekursive [[VHDL Glossar#access type]] zu definieren. (§3.3.1)

==== index constraint ====
Eine Gesetzmäßigkeit ( [[VHDL Glossar#constraint]] ) die den Indexbereich ( [[VHDL Glossar#index range]] ) für jeden Index eines Feldtyps ( [[VHDL Glossar#array type]] ) bestimmt, und dabei die Grenzen ( [[VHDL Glossar#bound]] ) des Feldes festlegt. Ein index constraint ist kompatible mit einem array type , aber nur dann wenn diese Gesetzmäßigkeit ( constraint ) die durch alle diskreten Bereiche ( [[VHDL Glossar#discrete range]] ) innerhalb des index constraint festgelegt wird, kompatibel ist mit der korrespondierenden Indexuntermenge ( [[VHDL Glossar#index subtype]] ) in dem Feldtyp ( array type ). Ein Feldwert erfüllt einen index constraint , falls der Feldwert und der index constraint den selben index range auf jeder Indexposition besitzen. (§3.1, §3.2.1.1)

==== index range ====
Ein mehrdimensionales Feld hat für jede mögliche Sequenz von Indexwerten ein gut sichtbares Element, das sich durch die Auswahl eines Wertes für jeden Index (im vorgegebenen Befehl) zusammensetzt. Der mögliche Wert für einen gegebenen Index liegt innerhalb aller Werte, die zu dem dazugehörigen Bereich ( [[VHDL Glossar#range]] ) gehören. Dieser Bereich ( range ) von Werten wird als //index range// bezeichnet. (§3.2.1)

==== index subtype ====
Für eine vorgegebene Position eines Feldes wird der //index subtype// durch das Typkennzeichen der dazugehörenden //index subtype// -Definition beschrieben. (§3.2.1)

==== inertial delay ====
Ein Verzögerungs mode ll das für Schaltkreise verwendet wird; ein Impuls dessen Dauer kürzer ist als die Schaltzeit des Schaltkreises wird nicht übertragen. //Inertial delay// ist die Verzögerungsvorgabe ( //default delay mode// ) für [[VHDL Glossar#signal]] -Zuweisungen. (§8.4) 

==== initial value expression ====
Ein Ausdruck ( [[VHDL Glossar#expression]] ) der den Anfangswert festlegt, der einer [[VHDL Glossar#variable]] zugewiesen wird. (§4.3.1.3)

==== inputs ====
Die [[VHDL Glossar#signal]] , die durch die längste statische Vorsilbe ( [[VHDL Glossar#longest static prefix]] ) aller Signalnamen ( signal [[VHDL Glossar#name]] ) gekennzeichnet wird, erscheint als Erstes ( [[VHDL Glossar#primary]] ) in jedem Ausdruck ( [[VHDL Glossar#expression]] ) (außer bei Zeitausdrücken) innerhalb einer nebenläufigen signal -Zuweisung. (§9.5)

==== instance ====
Eine Subcomponent einer [[VHDL Glossar#design entity]] , dessen Prototyp eine Komponenten-declaration, design entity , oder eine [[VHDL Glossar#configuration]] [[VHDL Glossar#declaration]] ist. Jede [[VHDL Glossar#instance]] einer Komponente kann verschiedene [[VHDL Glossar#actual]] besitzen, die mit den [[VHDL Glossar#local port]] und [[VHDL Glossar#generic]] verbunden sind. Eine Komponenten-Instanziierungsanweisung deren Instanziierungsteil eine Komponente beschreibt ( [[VHDL Glossar#denote]] ), die eine Instanz ( [[VHDL Glossar#instance]] ) der dazugehörenden Komponente erschafft. Eine Komponenten-Instanziierungsanweisung, deren istanziierten Einheiten entweder eine design entity oder eine configuration declaration beschreiben, die wiederum eine instance der beschriebenen ( denote ) design entity erschaffen. (§9.6, §9.6.1, §9.6.2)

==== integer literal ====
Ein [[VHDL Glossar#abstract literal]] des [[VHDL Glossar#type]] [[VHDL Glossar#universal_integer]] , die keinen Basispunkt enthält. (§13.4)

==== integer type ====
Ein diskreter [[VHDL Glossar#scalar type]] , dessen Werte Integerzahlen in einem bestimmten Bereich ( [[VHDL Glossar#range]] ) repräsentieren. (§3.1, §3.1.2)

==== interface list ====
Eine Deklarationsliste die Schnittstellen-Objekte ( [[VHDL Glossar#object]] ) enthält und von einem Unterprogramm, einer Komponente, einer [[VHDL Glossar#design entity]] oder einer [[VHDL Glossar#block]] -Anweisung gefordert wird. (§4.3.2.1)

==== internal block ====
Ein verschachtelter [[VHDL Glossar#block]] in einer [[VHDL Glossar#design unit]] , der genauso über ein block statement definiert wird. (§1)

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

==== ISO 8859-1 ====
Der [[VHDL Glossar#ISO]] -lateinische-Zeichensatz. Das Package Standard enthält die Definition des Zeichenyps ( [[VHDL Glossar#type]] ), der den ISO -lateinischen Zeichensatz definiert. (§3.1.1, §14.2)

===== K =====
==== kernel process ====
Ein konzeptionelle Darstellung der eingesetzten Mittel, die die Aktivitäten eines benutzerdefinierten Prozesses während einer Simulation koordinieren. Ein Kernel-Prozess bedingt die Ausführung von Ein-/Ausgabe-Operationen, die Übertragung von [[VHDL Glossar#signal]] -Werten, und die Erneuerung impliziter Signalwerte ( [[VHDL Glossar#implicit signal]] ) [solche wie S'Stable(T)]; außerdem zeigt er Ereignisse ( [[VHDL Glossar#event]] ), die falls sie auftreten, Folgeprozesse zu diesen Ereignissen auslösen. (§12.6)

===== L =====
==== left of ====
Fall zwei Werte V1 und V2 zum gleichen Wertebereich gehören ( [[VHDL Glossar#belong (to a range)]] ) und der Bereich [[VHDL Glossar#range]] entweder ein wachsender Bereich ( [[VHDL Glossar#ascending range]] ) ist und V2 dabei grösser als V1 ist, oder der Bereich ist ein schrumpfender Bereich [[VHDL Glossar#descending range]] und V2 ist kleiner als V1. (§3.1)

==== left-to-right order ====
Falls Werte nach ihrer Größe innerhalbe eines [[VHDL Glossar#range]] von links nach rechts ( [[VHDL Glossar#left of]] ) aufsteigend geordnet sind. (§3.1)

==== library ====
//Siehe// [[VHDL Glossar#design library]].

==== library unit ====
Die Darstellung einer analysierten [[VHDL Glossar#design library]] innerhalb einer [[VHDL Glossar#design unit]] . (§11.1)

==== literal ====
Ein Wert der in einer Designbeschreibung direkt festgelegt wird. Ein literal kann ein [[VHDL Glossar#bit string literal]] , [[VHDL Glossar#enumeration literal]] , [[VHDL Glossar#numeric literal]] , [[VHDL Glossar#string literal]] , oder das literal null sein. (§7.3.1)

==== local generic ====
Ein Schnittstellenobjekt (interface [[VHDL Glossar#object]] ), das in einer component [[VHDL Glossar#declaration]] festgelegt wird. Es dient zur Verbindung eines [[VHDL Glossar#formal]] [[VHDL Glossar#generic]] in der [[VHDL Glossar#interface list]] einer Schnittstellenbeschreibung (entity) mit einem [[VHDL Glossar#actual]] generic oder mit dem Wert in der [[VHDL Glossar#design unit]] , der die Schnittstellenbeschreibung instanziiert. (§4.3, §4.3.2.2, §4.5)

==== local port ====
Ein [[VHDL Glossar#signal]] , das in der [[VHDL Glossar#interface list]] einer //component// [[VHDL Glossar#declaration]] beschrieben wird. Es dient der Verbindung eines [[VHDL Glossar#formal]] [[VHDL Glossar#port]] in der interface list einer Schnittstellenbeschreibung (entity) mit dem [[VHDL Glossar#actual]] port oder einem signal in der [[VHDL Glossar#design unit]] , das diese entity instanziiert. (§4.3, §4.3.2.2, §4.5)

==== locally static expression ====
Ein Ausdruck ( [[VHDL Glossar#expression]] ), der während der Analyse ( [[VHDL Glossar#analysis]] ) der [[VHDL Glossar#design unit]] ausgewertet wird, in der er auftritt. (§7.4, §7.4.1)

==== locally static name ====
Ein [[VHDL Glossar#name]] in dem jeder Ausdruck ( [[VHDL Glossar#expression]] ) lokal statisch ( //locally// [[VHDL Glossar#static]] ) ist (falls jeder diskrete Bereich ( [[VHDL Glossar#discrete range]] ) der als Teil des Namen auftritt, der einen locally [[VHDL Glossar#static range]] oder [[VHDL Glossar#subtype]] beschreibt und falls keine Vorsilbe in dem Name entweder ein [[VHDL Glossar#object]] oder ein Wert des [[VHDL Glossar#access type]] oder des Funktionsaufrufs ist). (§6.1)

==== locally static primary ====
Ein Teil einer bestimmten Gruppe ( [[VHDL Glossar#group]] ) von Anfangswerten, die [[VHDL Glossar#literal]] , bestimmte [[VHDL Glossar#constant]] und bestimmte [[VHDL Glossar#attribute]] einschliessen. (§7.4)

==== locally static subtype ====
Ein [[VHDL Glossar#subtype]] dessen Grenzen [[VHDL Glossar#bound]] und Richtungen während der Analyse ( [[VHDL Glossar#analysis]] ) der dazugehörigen [[VHDL Glossar#design unit]] beeinflußt werden können. (§7.4.1)

==== longest static prefix ====
Der [[VHDL Glossar#name]] eines [[VHDL Glossar#signal]] oder einer [[VHDL Glossar#variable]] , falls der name ein [[VHDL Glossar#static]] signal oder ein variable ist. Ansonsten ist die longest static prefix die längste Vorsilbe des name , der ein static signal oder ein variable name ist. (§6.1)

==== loop parameter ====
Eine [[VHDL Glossar#constant]] , die implizit über den "for"-Ausdruck einer Schleifenanweisung definiert wird. Sie dient zur Kontrolle der Schleifenwiederholungen. (§8.9)

==== lower bound ====
Für eine [[VHDL Glossar#null range]] L to R oder L downto R, der kleinere Wert aus L und R. (§3.1)

===== M =====
==== match ====
Die Eigenschaft einer Signatur, die mit dem Profil der [[VHDL Glossar#parameter]] und des Untertyps ( [[VHDL Glossar#subtype]] ) eines Unterprogramms oder eines [[VHDL Glossar#enumeration literal]] zusammenhängt. Die Signatur sagt man trifft (match) die [[VHDL Glossar#parameter and result type profile]] falls verschieden Bedingungen wahr sind. (§2.3.2)

==== matching elements ====
Zusammengehörige Elemente zweier Werte von gemischten Typen ( [[VHDL Glossar#composite type]] ), die für bestimmte logische oder relationale Operationen gebraucht werden. (§7.2.3)

==== member ====
Ein Teil ( [[VHDL Glossar#slice]] ) eines [[VHDL Glossar#object]] , ein [[VHDL Glossar#subelement]] oder ein object ; oder ein slice eines subelement eines object . (§3)

==== mode ====
Die Richtung. in der eine Information durch einen [[VHDL Glossar#port]] oder [[VHDL Glossar#parameter]] fließt. Die verschieden //modes// sind: **in**, **out**, **inout**, **buffer** oder **linkage**. (§4.3.2)

==== model ====
Das Resultat der Ausarbeitung ( [[VHDL Glossar#elaboration]] ) einer [[VHDL Glossar#design hierarchy]] . Dieses model kann zur Simulation des beschriebenen Designs ausgeführt werden ( [[VHDL Glossar#execute]] ). (§12, §12.6)

===== N =====
==== name ====
Eine Eigenschaft eines Bezeichners bezogen auf irgendeine [[VHDL Glossar#named entity]] . Jede Form von [[VHDL Glossar#declaration]] verbindet einen Bezeichner mit einer named entity . Es ist üblich auf verschiedenen Stellen im Deklarationbereichs ( [[VHDL Glossar#scope]] of a declaration ) diesen Bezeichner für die Meldungen zur dazugehörigen named entity zu benutzen; diese Stellen sind über Sichtbarkeitsregeln definiert. In diesem Fall wird der Bezeichner als Name der named entity bezeichnet. (§4, §6.1)

==== named association ====
In diesem verbundenen Element ( [[VHDL Glossar#association element]] ) erscheint explizit die formelle Bezeichnung ( [[VHDL Glossar#formal]] [[VHDL Glossar#designator]] ). (§4.3.2.2, §7.3.2)

==== named entity ====
Ein Begriff der mit einem Bezeichner verbunden ist: Ein [[VHDL Glossar#character literal]] , oder ein Operatorsymbol das aus einer expliziten oder impliziten [[VHDL Glossar#declaration]] hervorgeht. (§4)

==== net ====
Ein Auswahl von Treibern (drivers), [[VHDL Glossar#signal]] (eingeschlossen sind Ein/Ausgänge ( [[VHDL Glossar#port]] ) und [[VHDL Glossar#implicit signal]] ), [[VHDL Glossar#conversion function]] , und [[VHDL Glossar#resolution function]] die verschieden Prozesse miteinander verbinden. Die Initialisierung eines Schaltnetzes (net) tritt nach der Ausarbeitung ( [[VHDL Glossar#elaboration]] ) ein. Ein net wird bei jedem Simulationszyklus ( [[VHDL Glossar#simulation cycle]] ) aktualisiert ( [[VHDL Glossar#update]] ). (§12, §12.1, §12.6.2)

==== nonobject alias ====
Ein [[VHDL Glossar#alias]] dessen [[VHDL Glossar#designator]] , anders als bei einem Objekt,irgendeine [[VHDL Glossar#named entity]] beschreibt ( [[VHDL Glossar#denote]] ). (§4.3.3, §4.3.3.2)

==== nonpostponed process ====
Ein expliziter oder impliziter Prozess, dessen Quellanweisung nicht das reservierte Wort "postponed" einbindet. Falls ein nonpostponed process fortgesetzt wird ( [[VHDL Glossar#resume]] ) wird er im aktuellen [[VHDL Glossar#simulation cycle]] ausgeführt [[VHDL Glossar#execute]] ). Diese //nonpostponed processes// haben Zugriff auf die aktuellen Signalwerte ( [[VHDL Glossar#current value]] of [[VHDL Glossar#signal]] ), egal ob diese Werte zur aktuellen Modell-Zeit stabil sind oder nicht. (§9.2)

==== null array ====
Einige [[VHDL Glossar#discrete range]] in dem [[VHDL Glossar#index constraint]] eines Feldes die eine [[VHDL Glossar#null range]] definieren. (§3.2.1.1)

==== null range ====
Ein Bereich ( [[VHDL Glossar#range]] ) der eine leere Untermenge von Werten definiert. A range L to R ist ein //null range// , falls L > R, und range L downto R ist ein //null range// , falls L < R. (§3.1)

==== null slice ====
Ein Teil ( [[VHDL Glossar#slice]] ) dessen dazugehöriger [[VHDL Glossar#discrete range]] ein [[VHDL Glossar#null range]] ist. (§6.5)

==== null waveform element ====
Ein [[VHDL Glossar#waveform]] element, das zum Abschalten eines Treibers von einem [[VHDL Glossar#guarded signal]] verwendet wird. (§8.4.1)

==== null transaction ====
Eine [[VHDL Glossar#transaction]] , die bei der Auswertung eines [[VHDL Glossar#null waveform element]] erzeugt wird. (§8.4.1)

==== numeric literal ====
Ein [[VHDL Glossar#abstract literal]] oder ein [[VHDL Glossar#literal]] eines [[VHDL Glossar#physical type]] . (§7.3.1)

==== numeric type ====
Ein [[VHDL Glossar#integer type]] , ein [[VHDL Glossar#floating point type]] oder ein [[VHDL Glossar#physical type]] . (§3.1)

===== O =====
==== object ====
Eine [[VHDL Glossar#named entity]] , die den Wert eines vorgegebenen [[VHDL Glossar#type]] hat. Ein object kann eine [[VHDL Glossar#constant]] , ein [[VHDL Glossar#signal]] , eine [[VHDL Glossar#variable]] oder ein File sein. (§4.3.3)

==== object alias ====
Ein [[VHDL Glossar#alias]] , dessen alias [[VHDL Glossar#designator]] ein [[VHDL Glossar#object]] (eine [[VHDL Glossar#constant]] , ein [[VHDL Glossar#signal]] , eine [[VHDL Glossar#variable]] oder ein File) beschreibt. (§4.3.3, §4.3.3.1)

==== overloaded ====
Namen oder [[VHDL Glossar#enumeration literal]] die zwei verschiedene Entities beschreiben. Enumeration [[VHDL Glossar#literal]] , [[VHDL Glossar#subprogram specification]] und vordefinierte Operatoren ( [[VHDL Glossar#predefined operator]] ) können überladen werden. Auf jedem Platz auf dem ein überladenes enumeration literal im Programmtext auftritt, muß der [[VHDL Glossar#type]] des enumeration literal aus dem Kontext bestimmbar sein. (§2.1, §2.3, §2.3.1, §2.3.2, §3.1.1)

===== P =====
==== parameter ====
Eine [[VHDL Glossar#constant]] , ein [[VHDL Glossar#signal]] , eine [[VHDL Glossar#variable]] , oder ein File , das in der [[VHDL Glossar#interface list]] einer [[VHDL Glossar#subprogram specification]] beschrieben ist. Die Charakteristiken einer Objektklasse (class of [[VHDL Glossar#object]] ), zu der ein vorgegebener parameter gehört, sind ebenfalls Merkmale dieses parameter . Außerdem hat ein parameter einen dazugehörigen [[VHDL Glossar#mode]] , der die mögliche Datenflußrichtung durch den parameter festlegt. (§2.1.1, §2.1.1.1, §2.1.1.2, §2.1.1.3, §2.3, §2.6)

==== parameter interface list ====
Eine [[VHDL Glossar#interface list]] , die die [[VHDL Glossar#parameter]] für ein Unterprogramm deklariert. Diese Liste kann Schnittstellen-(interface) [[VHDL Glossar#constant]] [[VHDL Glossar#declaration]] , interface [[VHDL Glossar#signal]] declaration , interface [[VHDL Glossar#variable]] declaration , interface file declaration oder irgendeine Kombination derselbigen enthalten. (§4.3.2.1)

==== parameter type profile ====
Zwei [[VHDL Glossar#formal]] [[VHDL Glossar#parameter]] -Listen, die die gleiche Anzahl von Parametern und auf jeder parameter -Position bei korrespondierenden Parametern den gleichen [[VHDL Glossar#base type]] besitzen. (§2.3)

==== parameter and result type profile ====
Zwei Unterprogramme die im [[VHDL Glossar#parameter type profile]] übereinstimmen und entweder haben beide Funktionen den gleichen [[VHDL Glossar#base type]] oder keines von beiden ist eine Funktion. (§2.3)

==== parent ====
Ein Prozess oder ein Unterprogramm das einen Prozeduraufruf oder einen Aufruf eins //parent// der gegebene Prozedur enthält. (§2.2)

==== passive process ====
Eine Prozessanweisung in der weder der Prozess selber, noch irgendeine Prozedur, für die der Prozess ein [[VHDL Glossar#parent]] ist, eine [[VHDL Glossar#signal]] -Zuweisung enthalten. (§9.2)

==== physical literal ====
Ein [[VHDL Glossar#numeric literal]] des [[VHDL Glossar#physical type]] . (§3.1.3)

==== physical type ====
Ein numerischer [[VHDL Glossar#scalar type]] , der verwendet wird, um eine quantitative Messung darzustellen. Jeder Wert des //physical type// besteht zu einem Teil aus einem Integerwert. Jeder Wert des //physical type// ist ein Vielfaches vom Ganzen der [[VHDL Glossar#primary]] Messeinheit für diesen Typ. (§3.1, §3.1.3)

==== port ====
Ein Kanal für die dynamische Kommunikation zwischen einem [[VHDL Glossar#block]] und seiner Umgebung. Ein [[VHDL Glossar#signal]] , das in der [[VHDL Glossar#interface list]] einer [[VHDL Glossar#entity declaration]] , in der Überschrift einer block -Anweisung oder in der interface list einer component [[VHDL Glossar#declaration]] beschrieben ist. Zusätzlich zu den Merkmalen der Signale ( signal ) haben port einen associated [[VHDL Glossar#mode]] ; dieser mode bestimmt die erlaubte Datenflußrichtung durch den port . (§1.1.1.2, §4.3.1.2)

==== port interface list ====
Eine [[VHDL Glossar#interface list]] , die die Ein- (inputs) und Ausgänge (outputs) eines [[VHDL Glossar#block]] , einer component, oder einer [[VHDL Glossar#design entity]] festlegen. Diese Liste besteht komplett aus den [[VHDL Glossar#signal]] [[VHDL Glossar#declaration]] . (§1.1.1, §1.1.1.2, §4.3.2.1, §4.3.2.2, §9.1)

==== positional association ====
Ein [[VHDL Glossar#association element]] , das nicht explizit einen [[VHDL Glossar#formal]] [[VHDL Glossar#designator]] enthalten muß. Ein [[VHDL Glossar#actual]] designator auf einer gegebenen Position in einer [[VHDL Glossar#association list]] entspricht dem interface element auf der selben Position in der [[VHDL Glossar#interface list]] . (§4.3.2.2, §7.3.2)

==== postponed process ====
Ein expliziter oder impliziter Prozess dessen Quellanweisung das reservierte Wort "postponed" enthält. Falls ein //postponed process// fortgesetzt wird (is [[VHDL Glossar#resume]]d ) wird er nicht ausgeführt ( [[VHDL Glossar#execute]] ), bis der letzte [[VHDL Glossar#simulation cycle]] zur aktuellen Modellzeit ausgeführt wurde. So ein //postponed process// ermöglicht den Zugriff auf Werte [[VHDL Glossar#signal]] , die zur akutellen Simulationszeit stabil sind. (§9.2)

==== predefined operators ====
Implizit definierte Operatoren die mit vordefinierten Typen ( [[VHDL Glossar#type]] ) arbeiten. Jeder vordefinierte //predefined operator// ist eine reine Funktion ( [[VHDL Glossar#pure function]] ). Nicht vordefinierte //predefined operators// besitzen [[VHDL Glossar#name]] [[VHDL Glossar#formal]] [[VHDL Glossar#parameter]] ; deshalb kann eine [[VHDL Glossar#named association]] association nicht verwendet werden wenn eine vordefinierte Operation aufgerufen wird. (§7.2, §14.2)

==== primary ====
Eines der Elemente aus denen sich ein Ausdruck ( [[VHDL Glossar#expression]] ) zusammensetzt. Jedes //primary// hat einen Wert und einen [[VHDL Glossar#type]] . (§7.1)

==== projected output waveform ====
Ein Folge von einer oder mehreren [[VHDL Glossar#transaction]] , die die aktuellen oder die zukünftigen Werte des Treibers darstellt.  (§12.6.1)

==== pulse rejection limit ====
Der zeitlich Grenzwert mit dem ein Signalwert, dessen Haltedauer größer ist als die erlaubte Grenze, propagiert wird. Ein //pulse rejection limit// wird über das reservierte Wort reject in einer zuerst verzögerten [[VHDL Glossar#signal]] -Zuweisung spezifiziert. (§8.4)

==== pure function ====
Eine Funktion die immer, wenn sie mit den gleichen [[VHDL Glossar#parameter]] aufgerufen wird, den selben Wert zurückgibt. Eine [[VHDL Glossar#impure function]] kann in diesem Fall auch unterschiedliche Werte zurückgeben. (§2.1)

===== Q =====
==== quiet ====
Falls in einem gegebenen [[VHDL Glossar#simulation cycle]] das [[VHDL Glossar#signal]] nicht aktiv ist. (§12.6.2)

===== R =====
==== range ====
Eine genaue Untermenge von Werten des skalaren Typs ( [[VHDL Glossar#scalar type]] ). (§3.1)

==== range constraint ====
Ein Konstrukt das den Wertebereich ( [[VHDL Glossar#range]] of values) eines Typs ( [[VHDL Glossar#type]] ) festlegt.

Ein range constraint ist kompatibel zu einem [[VHDL Glossar#subtype]] , falls jede Grenze [[VHDL Glossar#bound]] des Bereichs ( range ) zu dem Subtyp gehört ( [[VHDL Glossar#belong (to a subtype)]] ) oder falls der //range constraint// einen [[VHDL Glossar#null range]] definiert. Die Richtung eines range constraint ist die selbe Richtung wie die seines Bereichs ( range ). (§3.1, §3.1.2, §3.1.3, §3.1.4)

==== read ====
Der Wert eines Objekts ( [[VHDL Glossar#object]] ) sagt man wird gelesen, falls sein Wert gezeigt wird ( [[VHDL Glossar#reference]] ) oder falls verschieden der Attribute ( [[VHDL Glossar#attribute]] ) gezeigt werden. (§4.3.2)

==== real literal ====
Ein [[VHDL Glossar#abstract literal]] des [[VHDL Glossar#type]] [[VHDL Glossar#universal_real]] der eine Basisstelle enthält. (§13.4)

==== record type ====
Ein [[VHDL Glossar#composite type]] , dessen Werte sich aus benannten ( [[VHDL Glossar#name]] ) Elementen zusammensetzt. (§3.2.2, §7.3.2.1)

==== reference ====
Der Zugriff auf eine [[VHDL Glossar#named entity]] . Jedes Auftreten eines [[VHDL Glossar#designator]] (ein [[VHDL Glossar#name]] , [[VHDL Glossar#character literal]] , oder operator symbol ) ist eine reference zu der named entity die von dem Designator beschrieben wird ( [[VHDL Glossar#denote]] ), ausgenommen der designator tritt in einer abgeschlossenen Bibliothek ( [[VHDL Glossar#library]] ) auf oder wird abgeschlossen benutzt. (§10.4, §11.2)

==== register ====
Eine Art von einem [[VHDL Glossar#guarded signal]] , das seinen zuletzt erhaltenen Wert speichert, auch wenn alle Treiber abgeschaltet sind. (§4.3.1.2)

==== regular structure ====
[[VHDL Glossar#instance]] aus einer oder mehrerer Komponenten die zusammengefügt oder mit Hilfe von [[VHDL Glossar#signal]] auf eine wiederholbare Weise verbunden sind. Jede instance kann Merkmale besitzen, die von seiner Position in einer Gruppe von Instanzen ( [[VHDL Glossar#group]] of instance ) abhängt. Reguläre Strukturen können mit Hilfe einer generate-Anweisung dargestellt werden. (§9.7)

==== resolution ====
Ein Prozess der den [[VHDL Glossar#resolved value]] eines [[VHDL Glossar#resolved signal]] bestimmt, basiert auf den Werten vieler zu diesem Signal gehörender Quellen ( source ). (§2.4, §4.3.1.2)

==== resolution function ====
Eine benutzerdefinierte Funktion die den [[VHDL Glossar#resolved value]] eines [[VHDL Glossar#resolved signal]] berechnet. (§2.4, §4.3.1.2)

==== resolution limit ====
Die [[VHDL Glossar#primary]] Einheit des [[VHDL Glossar#type]] TIME (Vorgabe: 1 Femtosekunde). Jeder Zeitwert, dessen Wert kleiner ist als diese Grenze wird auf NULL abgerundet. (§3.1.3.1)

==== resolved signal ====
Ein Signal ( [[VHDL Glossar#signal]] ) das eine dazugehörige [[VHDL Glossar#resolution function]] besitzt. (§4.3.1.2)

==== resolved value ====
Die Ausgänge einer [[VHDL Glossar#resolution function]] verbunden mit einem [[VHDL Glossar#resolved signal]] , das bestimmt wird mit Hilfe einer Funktion, die eine Auswahl der Eingänge (inputs) von mehreren Signalquellen ( [[VHDL Glossar#source]] of the [[VHDL Glossar#signal]] ) bearbeitet. (§2.4, §4.3.1.2)

==== resource library ====
Eine Bibliothek ( [[VHDL Glossar#library]] ), die [[VHDL Glossar#library unit]] enthält, auf die innerhalb der analysierten [[VHDL Glossar#reference]] verwiesen wird ( [[VHDL Glossar#design unit]] ). (§11.2)

==== result subtype ====
Der [[VHDL Glossar#subtype]] des Ergebnisses einer Funktion. (§2.1)

==== resume ====
Die Ausführung einer Warteanweisung in einem abgeschlossenen Prozess, falls die Bedingungen auf die, die Warteanweisung wartet, erfüllt werden. Falls der abgeschlossen Prozess ein [[VHDL Glossar#nonpostponed process]] ist, wird er nachträglich während des aktuellen Simulationsdurchlaufs ( [[VHDL Glossar#execute]] ) ausgeführt ( [[VHDL Glossar#simulation cycle]] ). Falls der Prozess aber ein [[VHDL Glossar#postponed process]] ist wird er während des letzten Simulationsdurchlaufs zur aktuellen Simulationszeit ausgeführt. (§12.6.3)

==== right of ====
Falls die Werte V1 und V2 zu einem Bereich gehören ( [[VHDL Glossar#belong (to a range)]] ) und der Bereich steigend ist ( [[VHDL Glossar#ascending range]] ), dann muß V2 vor V1 liegen, oder der Bereich ist fallend, dann muß V2 V1 folgen.  (§14.1)

===== S =====
==== satisfy ====
Eine Werteigenschaft die von irgendeiner Bedingung ( [[VHDL Glossar#constraint]] ) abhängt. Ein Wert, sagt man, erfüllt ( //satisfy// ) eine Bedingung ( constraint ), falls der Wert in einer Untermenge ist, die durch diese Bedingung bestimmt wird. (§3, §3.2.1.1)

==== scalar type ====
Ein [[VHDL Glossar#type]] , dessen Werte keine Elemente besitzen. Skalare type bestehen aus [[VHDL Glossar#enumeration type]] , [[VHDL Glossar#integer type]] , [[VHDL Glossar#physical type]] und [[VHDL Glossar#floating point type]] . enumeration type und integer type werden als [[VHDL Glossar#discrete type]] bezeichnet. integer type , floating point type und physical type werden als [[VHDL Glossar#numeric type]] bezeichnet. Alle scalar type werden geordert; das heisst, alle relationalen Operatoren sind für ihre Werte vordefiniert. (§3, §3.1)

==== scope ====
Ein Teil des Textes in dem eine [[VHDL Glossar#declaration]] sichtbar ( [[VHDL Glossar#visible]] ) sein kann. Dieser Teil wird durch die Sichtbarkeits- und Überladeregeln definiert. (§10.2)

==== selected name ====
Syntaktisch, hat ein Name ( [[VHDL Glossar#name]] ) eine Vorsilbe und eine Nachsilbe, die durch einen Punkt getrennt sind. Verschieden //selected name// werden verwendet, um Datensatzelemente oder [[VHDL Glossar#object]] , die durch einen [[VHDL Glossar#access value]] beschrieben werden, zu beschreiben ( [[VHDL Glossar#denote]] ). Die verbleibenden //selected name// werden als [[VHDL Glossar#expanded name]] notiert. (§6.3, §8.1)

==== sensitivity set ====
Eine Menge von [[VHDL Glossar#signal]] , auf die eine Warteanweisung sensitiv reagiert. Das //sensitivity set// wird explizit in einer on-Klausel angegeben, oder wird in eine until-Klause impliziert. (§8.1)

==== sequential statements ====
Anweisungen, die in der Reihenfolge ausgeführt ( [[VHDL Glossar#execute]] ) werden, in der sie angeordnet sind. //Sequential Statements// werden in algorithmischen Beschreibungen verwendet. (§8)

==== short-circuit operation ====
Eine Operation in der der eine Operand erst aktualisiert wird, falls der andere Operand einen bestimmten Wert hat. //Short-circuit- Opertionen// sind vordefinierte logische Operationen wie and, or, nand und nor für Operanden vom Typ ( [[VHDL Glossar#type]] ) BIT und BOOLEAN. (§7.2)

==== signal ====
Ein [[VHDL Glossar#object]] mit einer Reihe von vergangenen Werten. Ein signal kann verschiedenste Treiber haben, jeder mit einem aktuellen Wert ( //current value// ) und zu erwartenden Werten. Der Ausdruck signal bezieht sich auf Objekte ( object ) die durch signal [[VHDL Glossar#declaration]] oder [[VHDL Glossar#port]] declaration festgelegt werden. (§4.3.1.2)

==== signal transform ====
Eine sequentielle Anweisung ( [[VHDL Glossar#sequential statement]] ) innerhalb eines [[VHDL Glossar#statement transform]] die bestimmt, welche von verschiedenen [[VHDL Glossar#waveform]] , falls es welche gibt, einem Ausgangssignal (output [[VHDL Glossar#signal]] ) zugewiesen wird. Eine Signalumfomung ( //signal transform// ) kann eine sequentielle Signalzuweisung sein, eine if-Anweisung, eine case-Anweisung oder eine Nullanweisung. (§9.5)

==== simple name ====
Der Bezeichner, der mit einer [[VHDL Glossar#named entity]] , entweder in seiner eigenen [[VHDL Glossar#declaration]] oder in einer [[VHDL Glossar#alias]] declaration , verbunden ist. (§6.2)

==== simulation cycle ====
Eine Wiederholung in der wiederholten Ausführung des Prozesses, der durch Prozessanweisungen in einem Model ( [[VHDL Glossar#model]] ) definiert wird. Der erste Simulationszyklus ( //simulation cycle// ) tritt nach der Initialisierung auf. Ein //simulation cycle// kann ein [[VHDL Glossar#delta cycle]] oder ein Zyklus mit fortschreitender Zeit sein. (§12.6.4)

==== single-object declaration ====
Eine [[VHDL Glossar#object]] [[VHDL Glossar#declaration]] , deren Kennzeichenliste einen einzelnen Bezeichner enthält; sie wird auch als mehrfache object declaration Liste bezeichnet falls die Kennzeichenliste mehr als einen Bezeichner enthält. (§4.3.1)

==== slice ====
Ein eindimensionales Feld einer Folge aufeinanderfolgender Elemente eines anderen eindimensionalen Feldes. (§6.5)

==== source ====
Der Erzeuger eines Signalwertes (value of a [[VHDL Glossar#signal]] ). Die Quelle ( //source// ) kann ein Treiber oder der Ein-, Ausgang ( [[VHDL Glossar#port]] ) eines Blocks ( [[VHDL Glossar#block]] ) sein, mit dem ein Signal ( signal ) oder eine Mischung aus Quellen ( sources ) verbunden ist. (§4.3.1.2)

==== specification ====
Eine Klasse von Konstrukten, die Zusatzinformationen mit einer ( [[VHDL Glossar#named entity]] ) verbindet. Es gibt drei verschieden Arten von [[VHDL Glossar#attribute]] specification , [[VHDL Glossar#configuration]] specification und disconnection specification . (§5)

==== statement transform ====
Das erste [[VHDL Glossar#sequential statement]] in einem Prozess, welches äquivalent ist zu einer nebenläufigen Signalzuweisung ( //signal assignment statement// ). Die Zuweisung (statement) transform definiert die Aktionen der nebenläufigen Signalzuweisungen, wenn diese ausgeführt ( [[VHDL Glossar#execute]] ) werden. Dem //statement transform// folgt eine Warteanweisung, die die letzte Anweisung in dem äquivalenten Prozess darstellt. (§9.5)

==== static ====
//Siehe// [[VHDL Glossar#locally static expression]] und [[VHDL Glossar#globally static expression]].

==== static name ====
Ein [[VHDL Glossar#name]] für den jeder Ausdruck ( [[VHDL Glossar#expression]] ,) der als Teil dieses name auftritt (z.B als ein Index-Ausdruck), eine statische ( [[VHDL Glossar#static]] ) expression ist [falls jeder diskrete Bereich ( [[VHDL Glossar#discrete range]] ) der als Teil des Namen auftritt einen [[VHDL Glossar#static range]] oder einen [[VHDL Glossar#subtype]] beschreibt und falls eine Vorsilbe in der Benennung ( name ) weder ein [[VHDL Glossar#object]] noch der Wert eines [[VHDL Glossar#access type]] oder eines Funktionsaufrufs ist]. (§6.1)

==== static range ====
Ein Bereich ( [[VHDL Glossar#range]] ), dessen Grenzen ( [[VHDL Glossar#bound]] ) statische ( [[VHDL Glossar#static]] ) [[VHDL Glossar#expression]] sind. (§7.4)

==== static signal name ====
Ein [[VHDL Glossar#static name]] , der ein Signal ( [[VHDL Glossar#signal]] ) beschreibt ( [[VHDL Glossar#denote]] ). (§6.1)

==== static variable name ====
Ein [[VHDL Glossar#static name]] , der eine Variable ( [[VHDL Glossar#variable]] ) beschreibt ( [[VHDL Glossar#denote]] ). (§6.1)

==== string literal ====
Eine Folge graphischer Zeichen oder ein leerer Bereich, der zwischen zwei Anführungszeichen (") eingeschlossen ist. Der [[VHDL Glossar#type]] eines string literal wird aus dem Kontext heraus bestimmt. (§7.3.1, §13.6)

==== subaggregate ====
Ein [[VHDL Glossar#aggregate]] , das als Ausdruck ( [[VHDL Glossar#expression]] ) in einer Elementverbindung eines anderen mehrdimensionalen Feld- aggregate auftritt. Das subaggregate ist ein (n-1)-dimensionales Feld- aggregate , dabei ist n die Dimension des äußeren aggregate . Aggregates von mehrdimensionalen Feldern werden in einer row-major-Reihenfolge (der ganz rechte Index änder sich am schnellsten) dargestellt. (§7.3.2.2)

==== subelement ====
Das Element eines anderen Elements. Wenn andere //subelements// ausgeschlossen sind, wird das Hauptelement verwendet. (§3)

==== subprogram specification ====
Die //subprogram specification// spezifiziert den [[VHDL Glossar#designator]] eines Unterprogramms, irgendwelche [[VHDL Glossar#formal]] [[VHDL Glossar#parameter]] des Unterprogramms und den Ergebnistyp (result [[VHDL Glossar#type]] ) für ein Funktionsunterprogramm. (§2.1)

==== subtype ====
Ein Typ ( [[VHDL Glossar#type]] ) mit einer Bedingung ( [[VHDL Glossar#constraint]] ). Ein Wert gehört zu einem //subtype// eines type , falls er zu dem type gehört und die Bedingungen ( constraint ) erfüllt; solch ein type wird Basistyp ( [[VHDL Glossar#base type]] ) des //subtype// bezeichnet Ein type ist sein eigener subtype . Ein solcher //subtype// wird als unconstrained bezeichnet, weil er keinen einschränkenden Bedingungen gehorchen muß. (§3)

==== suspend ====
Ein Prozess der seine Ausführung stoppt und auf ein Ereigniss ( [[VHDL Glossar#event]] ) oder für eine bestimmte Zeitdauer wartet um weiterzulaufen. (§12.6.4)

===== T =====
==== timeout interval ====
Die maximale Zeit, die ein Prozess unterbrochen ( [[VHDL Glossar#suspend]] ) wird und die durch das until-Schlüsselwort einer Wait-Anweisung festgelegt wird. (§8.1)

==== to the left of ====
//Siehe// [[VHDL Glossar#left of]].

==== to the right of ====
//Siehe// [[VHDL Glossar#right of]].

==== transaction ====
Die paarweise Zusammensetzung von Werten und Zeit. Der Wert steht für einen aktuellen oder zukünftigen Wert des Treibers; die Zeit steht für die relative Verzögerung bis der Wert aktuell ist ( [[VHDL Glossar#current value]] ). (§12.6.1)

==== transport delay ====
Ein optionales Verzögerungsmodell für die Signalzuweisung ( [[VHDL Glossar#signal]] assignment). Ein //transport delay// ist charakteristisch für Hardwarebausteine (so wie für Überlandleitungen), die eine annähernd unendliche Frequenzantwort besitzen: irgendein Impuls wird übertragen, dabei spielt es keine Rolle wie kurz die Impulsdauer ist. (§8.4)

==== type ====
Eine Menge von Werten und von Operationen. (§3)

==== type conversion ====
Ein Ausdruck ( [[VHDL Glossar#expression]] ) der einen Wert einer subexpression von einem Typ ( [[VHDL Glossar#type]] ) zum bestimmten (designated) type einer type -Konversion verändert. Verbindungen in der Form einer Typ-Konversion sind ebenfalls erlaubt. Diese Verbindungen haben Funktionen und Restriktionen ähnlich wie bei [[VHDL Glossar#conversion function]] aber können an Stellen verwendet werden, wo conversion function nicht verwendet werden können. In beiden Fällen ( expression und Verbindungen), muß der konvertierte type eng verwandt ( [[VHDL Glossar#closely related types]] ) zu dem [[VHDL Glossar#designated type]] sein. (§4.3.2.2, §7.3.5)

===== U =====
==== unaffected ====
Eine Wellenform ( [[VHDL Glossar#waveform]] ) in einer nebenläufigen [[VHDL Glossar#signal]] -Zuweisung, welche den Zieltreiber nicht beeinträchtigt. (§8.4, §9.5.1)

==== unassociated formal ====
Ein [[VHDL Glossar#formal]] , das nicht mit einem [[VHDL Glossar#actual]] verbunden ist. (§5.2.1.2)

==== unconstrained subtype ====
Ein [[VHDL Glossar#subtype]] der zu einer Bedingung gehört, die keine Restriktionen zur Folge hat. (§3, §4.2)

==== unit name ====
Ein [[VHDL Glossar#name]] der durch die [[VHDL Glossar#declaration]] einer Einheit (entweder einer [[VHDL Glossar#primary]] unit declaration oder einer secondary unit declaration ) in einer [[VHDL Glossar#physical type]] declaration festgelegt wird. (§3.1.3)

==== universal_integer ====
Ein anonymer ( [[VHDL Glossar#anonymous]] ) vordefinierter [[VHDL Glossar#integer type]] , der für alle [[VHDL Glossar#integer literal]] verwendet wird. Die Stellennummer eines Integerwerts ist der korrespondierende Wert des [[VHDL Glossar#type]] [[VHDL Glossar#universal_integer]] . (§3.1.2, §7.3.1, §7.3.5)

==== universal_real ====
Ein anonymer ( [[VHDL Glossar#anonymous]] ) vordefinierter [[VHDL Glossar#type]] , der für [[VHDL Glossar#literal]] des [[VHDL Glossar#floating point type]] verwendet wird. Andere floating point type haben keine literal . Dennoch existiert für jeden floating point type eine implizite Umwandlung, die einen Wert vom type [[VHDL Glossar#universal_real]] in einen korrespondierenden Wert (falls es einen gibt) des floating point type verwandelt. (§3.1.4, §7.3.1, §7.3.5)

==== update ====
Die Wertaktualisierung eines Signals ( [[VHDL Glossar#signal]] ), einer [[VHDL Glossar#variable]] , oder einer Datei (file). Der Wert eines Signals wird aktualisiert ( updated ), falls das Signal als das Ziel (oder als die Komponente eines solchen Ziels) einer Signalzuweisung auftritt; oder (indirekt) falls das Signal mit einem Schnittstellen- [[VHDL Glossar#object]] des Modus ( [[VHDL Glossar#mode]] ) out, buffer, inout oder linkage verbunden wird oder falls eines der [[VHDL Glossar#subelement]] aktualisiert wird ( updated ). Man spricht ebenfalls von einer Aktualisierung falls das Signal subelement oder Bestandteil ( [[VHDL Glossar#slice]] ) eines [[VHDL Glossar#resolved signal]] ist, das aktualisiert wird.

Der Wert einer variable wird aktualisiert ( [[VHDL Glossar#update]] ), falls die Variable als Ziel oder als Teilkomponente des Ziels einer Variablenzuweisung auftritt; (indirekt,) falls die Variable mit einem Schnittstellen- object des Modus ( mode ) out oder linkage verbunden wird oder falls eines der Variablen- subelement s aktualisiert wird ( updated ). Der Wert einer Datenmenge (file) wird aktualisiert falls eine WRITE-Operation mit dem file- object ausgeführt wird. (§4.3.2)

==== upper bound ====
Für einen [[VHDL Glossar#null range]] L to R oder L downto R, der größere Wert aus L und R. (§3.1)

===== V =====
==== variable ====
Ein [[VHDL Glossar#object]] mit einem einzelnen [[VHDL Glossar#current value]] . (§4.3.1.3)

==== visible ====
Falls die [[VHDL Glossar#declaration]] eines Bezeichners eine mögliche Bedeutung des Auftretens dieses Bezeichners innerhalb der declaration definiert. Eine visible declaration ist bei der Auswahl sichtbar ( visible - z.B bei der Verwendung eines [[VHDL Glossar#expanded name]] ) oder [[VHDL Glossar#directly visible]] (z.B bei der Verwendung eines [[VHDL Glossar#simple name]] ). (§10.3)

===== W =====
==== waveform ====
Ein Serie von Signalbewegungen ( [[VHDL Glossar#transaction]] ), die alle einen zukünftigen Wert des Signaltreibers ( [[VHDL Glossar#signal]] ) darstellen. Die transaction werden in einer //waveform// nach der Zeit angeordnet, so daß die frühere transaction auch vor der späteren erscheint. (§8.4)

==== whitespace character ====
Ein Leerraum, ein nicht unterbrechender Leerraum, oder ein horizontales Tabulatorkennzeichen (SP, NBSP, or HT). (§14.3)

==== working library ====
In diese [[VHDL Glossar#design library]] wird die [[VHDL Glossar#library unit]] eingefügt, welche bei der Analyse ( [[VHDL Glossar#analysis]] ) einer [[VHDL Glossar#design unit]] entsteht. (§11.2)

Ende des Dokuments.