[lex.fcon] - C++17 → C++20

Files changed (1) hide show

tmp/tmp6s1ghyza/{from.md → to.md} +51 -46

tmp/tmp6s1ghyza/{from.md → to.md} RENAMED Viewed

@@ -1,23 +1,23 @@
-### Floating literals <a id="lex.fcon">[[lex.fcon]]</a>
 ``` bnf
-floating-literal:
-    decimal-floating-literal
-    hexadecimal-floating-literal
 ```
 ``` bnf
-decimal-floating-literal:
-    fractional-constant exponent-partₒₚₜ floating-suffixₒₚₜ
-    digit-sequence exponent-part floating-suffixₒₚₜ
 ```
 ``` bnf
-hexadecimal-floating-literal:
-    hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part floating-suffixₒₚₜ
-    hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part floating-suffixₒₚₜ
 ```
 ``` bnf
 fractional-constant:
     digit-sequenceₒₚₜ '.' digit-sequence
@@ -52,46 +52,51 @@ digit-sequence:
     digit
     digit-sequence '''ₒₚₜ digit
 ```
 ``` bnf
-floating-suffix: one of
     'f l F L'
 ```
-A floating literal consists of an optional prefix specifying a base, an
-integer part, a radix point, a fraction part, an `e`, `E`, `p` or `P`,
-an optionally signed integer exponent, and an optional type suffix. The
-integer and fraction parts both consist of a sequence of decimal (base
-ten) digits if there is no prefix, or hexadecimal (base sixteen) digits
-if the prefix is `0x` or `0X`. The floating literal is a *decimal
-floating literal* in the former case and a *hexadecimal floating
-literal* in the latter case. Optional separating single quotes in a
-*digit-sequence* or *hexadecimal-digit-sequence* are ignored when
-determining its value.
-[*Example 1*: The floating literals `1.602'176'565e-19` and
-`1.602176565e-19` have the same value. — *end example*]
-Either the integer part or the fraction part (not both) can be omitted.
-Either the radix point or the letter `e` or `E` and the exponent (not
-both) can be omitted from a decimal floating literal. The radix point
-(but not the exponent) can be omitted from a hexadecimal floating
-literal. The integer part, the optional radix point, and the optional
-fraction part, form the *significand* of the floating literal. In a
-decimal floating literal, the exponent, if present, indicates the power
-of 10 by which the significand is to be scaled. In a hexadecimal
-floating literal, the exponent indicates the power of 2 by which the
-significand is to be scaled.
-[*Example 2*: The floating literals `49.625` and `0xC.68p+2` have the
-same value. — *end example*]
-If the scaled value is in the range of representable values for its
-type, the result is the scaled value if representable, else the larger
-or smaller representable value nearest the scaled value, chosen in an
-*implementation-defined* manner. The type of a floating literal is
-`double` unless explicitly specified by a suffix. The suffixes `f` and
-`F` specify `float`, the suffixes `l` and `L` specify `long` `double`.
 If the scaled value is not in the range of representable values for its
-type, the program is ill-formed.

+### Floating-point literals <a id="lex.fcon">[[lex.fcon]]</a>
 ``` bnf
+floating-point-literal:
+    decimal-floating-point-literal
+    hexadecimal-floating-point-literal
 ```
 ``` bnf
+decimal-floating-point-literal:
+    fractional-constant exponent-partₒₚₜ floating-point-suffixₒₚₜ
+    digit-sequence exponent-part floating-point-suffixₒₚₜ
 ```
 ``` bnf
+hexadecimal-floating-point-literal:
+    hexadecimal-prefix hexadecimal-fractional-constant binary-exponent-part floating-point-suffixₒₚₜ
+    hexadecimal-prefix hexadecimal-digit-sequence binary-exponent-part floating-point-suffixₒₚₜ
 ```
 ``` bnf
 fractional-constant:
     digit-sequenceₒₚₜ '.' digit-sequence
     digit
     digit-sequence '''ₒₚₜ digit
 ```
 ``` bnf
+floating-point-suffix: one of
     'f l F L'
 ```
+The type of a *floating-point-literal* is determined by its
+*floating-point-suffix* as specified in [[lex.fcon.type]].
+**Table: Types of *floating-point-literal*{s}** <a id="lex.fcon.type">[lex.fcon.type]</a>
+| *floating-point-suffix* | type            |
+| ----------------------- | --------------- |
+| none                    | `double`        |
+| `f` or `F`              | `float`         |
+| `l` or `L`              | `long` `double` |
+The *significand* of a *floating-point-literal* is the
+*fractional-constant* or *digit-sequence* of a
+*decimal-floating-point-literal* or the
+*hexadecimal-fractional-constant* or *hexadecimal-digit-sequence* of a
+*hexadecimal-floating-point-literal*. In the significand, the sequence
+of *digit*s or *hexadecimal-digit*s and optional period are interpreted
+as a base N real number s, where N is 10 for a
+*decimal-floating-point-literal* and 16 for a
+*hexadecimal-floating-point-literal*.
+[*Note 1*: Any optional separating single quotes are ignored when
+determining the value. — *end note*]
+If an *exponent-part* or *binary-exponent-part* is present, the exponent
+e of the *floating-point-literal* is the result of interpreting the
+sequence of an optional *sign* and the *digit*s as a base 10 integer.
+Otherwise, the exponent e is 0. The scaled value of the literal is
+s × 10ᵉ for a *decimal-floating-point-literal* and s × 2ᵉ for a
+*hexadecimal-floating-point-literal*.
+[*Example 1*: The *floating-point-literal*s `49.625` and `0xC.68p+2`
+have the same value. The *floating-point-literal*s `1.602'176'565e-19`
+and `1.602176565e-19` have the same value. — *end example*]
 If the scaled value is not in the range of representable values for its
+type, the program is ill-formed. Otherwise, the value of a
+*floating-point-literal* is the scaled value if representable, else the
+larger or smaller representable value nearest the scaled value, chosen
+in an *implementation-defined* manner.

Diff to HTML by rtfpessoa