# 2.4 Numeric Literals

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

There are two kinds of `numeric_literal`

s, *real literals* and *integer literals*. A real literal is a `numeric_literal`

that includes a point; an integer literal is a `numeric_literal`

without a point.

#### Syntax

2`numeric_literal`

` ::= `

`decimal_literal`

| `based_literal`

NOTE The type of an integer literal is *universal_integer*. The type of a real literal is *universal_real*.

## 2.4.1 Decimal Literals

1A `decimal_literal`

is a `numeric_literal`

in the conventional decimal notation (that is, the base is ten).

#### Syntax

2

3

4

4.1/2

5
An `exponent`

for an integer literal shall not have a minus sign.

Although this rule is in this subclause, it applies also to the next subclause.

#### Static Semantics

6An underline character in a `numeric_literal`

does not affect its meaning. The letter E of an `exponent`

can be written either in lower case or in upper case, with the same meaning.

Although these rules are in this subclause, they apply also to the next subclause.

An `exponent`

indicates the power of ten by which the value of the `decimal_literal`

without the `exponent`

is to be multiplied to obtain the value of the `decimal_literal`

with the `exponent`

.

#### Examples

8*Examples of decimal literals:*

12 0 1E6 123_456 -- integer literals
12.0 0.0 0.456 3.14159_26 -- real literals

#### Wording Changes from Ada 83

We have changed the syntactic category name `integer`

to be `numeral`

. We got this idea from ACID. It avoids the confusion between this and integers. (Other places don't offer similar confusions. For example, a `string_literal`

is different from a string.)

## 2.4.2 Based Literals

1[ A `based_literal`

is a `numeric_literal`

expressed in a form that specifies the base explicitly.]

#### Syntax

2`based_literal`

` ::= `

`base`

# `based_numeral`

[.`based_numeral`

] # [`exponent`

]

3
`base`

` ::= `

`numeral`

4
`based_numeral`

` ::= `

`extended_digit`

{[`underline`

] `extended_digit`

}

5
`extended_digit`

` ::= `

`digit`

| A | B | C | D | E | F

#### Legality Rules

6The *base* (the numeric value of the decimal `numeral`

preceding the first #) shall be at least two and at most sixteen. The `extended_digit`

s A through F represent the digits ten through fifteen, respectively. The value of each `extended_digit`

of a `based_literal`

shall be less than the base.

#### Static Semantics

7The conventional meaning of based notation is assumed. An `exponent`

indicates the power of the base by which the value of the `based_literal`

without the `exponent`

is to be multiplied to obtain the value of the `based_literal`

with the `exponent`

. The `base`

and the `exponent`

, if any, are in decimal notation.

The `extended_digit`

s A through F can be written either in lower case or in upper case, with the same meaning.

#### Examples

9*Examples of based literals:*

2#1111_1111# 16#FF# 016#0ff# -- integer literals of value 255
16#E#E1 2#1110_0000# -- integer literals of value 224
16#F.FF#E+2 2#1.1111_1111_1110#E11 -- real literals of value 4095.0

#### Wording Changes from Ada 83

The rule about which letters are allowed is now encoded in BNF, as suggested by Mike Woodger. This is clearly more readable.