VHDL Reference Guide

I [1]

I [0]

B [3] Z

X8657

Figure 4-7 Design Illustrating Use of Indexed Names

You can also use indexed names as assignment targets; see the

“Assignment Statements and Targets” section of the “Sequential Statements” chapter.

Literals

A literal (constant) operand can be a numeric literal, a character literal, an enumeration literal, or a string literal. The following sections describe these four kinds of literals.

Numeric Literals

Numeric literals are constant integer values. The two kinds of numeric literals are decimal and based. A decimal literal is written in base 10. A based literal can be written in a base from 2 to 16 and is composed of the base number, an octothorpe (#), the value in the

Expressions

given base, and another octothorpe (#); for example, 2#101# is decimal 5.

The digits in either kind of numeric literal can be separated by n underscores. The following example shows several different numeric literals, all representing the same value, which is 170.

170

1_7_0 10#170# 2#1010_1010# 16#AA#

Character Literals

Character literals are single characters enclosed in single quotation marks, for example, ‘A’. Character literals are used both as values for operators and to define enumerated types, such as CHARACTER and BIT. See the “Enumeration Types” section of the “Data Types” chapter for the valid character types.

Enumeration Literals

Enumeration literals are values of enumerated types. The two kinds of enumeration literals are character literals and identifiers. Character literals were described previously. Enumeration identifiers are those literals listed in an enumeration type definition. The following example shows an enumeration type definition,

type SOME_ENUM is ( ENUM_ID_1, ENUM_ID_2, ENUM_ID_3);

If two enumerated types use the same literals, those literals are overloaded. You must qualify overloaded enumeration literals when you use them in an expression, unless their type can be determined from context (See the “Qualified Expressions” section of this chapter.) See “Enumeration Types” section of the “Data Types” chapter for more information.

The example below defines two enumerated types and shows some enumeration literal values.

type ENUM_1 is (AAA, BBB, ’A’, ’B’, ZZZ); type ENUM_2 is (CCC, DDD, ’C’, ’D’, ZZZ);

AAA -- Enumeration identifier of type ENUM_1 ’B’ -- Character literal of type ENUM_1

CCC -- Enumeration identifier of type ENUM_2

VHDL Reference Guide

String Literals

String literals are one-dimensional arrays of characters, enclosed in double quotes (" "). The two kinds of string literals follow.

•Character strings which are sequences of characters in double quotation marks, for example, "ABCD."

•Bit strings are similar to character strings but represent binary, octal, or hexadecimal values. For example, B"1101", O"15", and X"D" all represent decimal value 13.

A string literal’s type is a one-dimensional array of an enumerated type. Each of the characters in the string represents one element of the array. The following example shows character string literals.

"10101"

"ABCDEF"

Note: Null string literals ("") are not supported.

Bit strings, like based numeric literals, are composed of a base specific character, a double quotation mark, a sequence of numbers in the given base, and another double quotation mark. For example, B"0101" represents the bit vector 0101. A bit string literal consists of the base specifier B, O, or X, followed by a string literal. The bit string literal is interpreted as a bit vector, a one-dimensional array of the predefined type BIT. The base specifier determines the interpretation of the bit string as follows.

•B (binary)

The value is in binary digits (bits, 0 or 1). Each bit in the string represents one BIT in the generated bit vector (array).

•O (octal)

The value is in octal digits (0 to 7). Each octal digit in the string represents three BITs in the generated bit vector (array).

•X (hexadecimal)

The value is in hexadecimal digits (0 to 9 and A to F). Each hexadecimal digit in the string represents four BITs in the generated bit vector (array).