[lex.literal] - C++11 → C++14

Files changed (1) hide show

tmp/tmp8c3i9k84/{from.md → to.md} +85 -57

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

@@ -17,44 +17,58 @@ literal:
 ### Integer literals <a id="lex.icon">[[lex.icon]]</a>
 ``` bnf
 integer-literal:
- decimal-literal integer-suffixₒₚₜ
     octal-literal integer-suffixₒₚₜ
     hexadecimal-literal integer-suffixₒₚₜ
 ```
 ``` bnf
 decimal-literal:
     nonzero-digit
-    decimal-literal digit
-```
-``` bnf
-octal-literal:
-    '0'
-    octal-literal octal-digit
 ```
 ``` bnf
 hexadecimal-literal:
     '0x' hexadecimal-digit
     '0X' hexadecimal-digit
-    hexadecimal-literal hexadecimal-digit
 ```
 ``` bnf
-nonzero-digit: one of
-    '1 2 3 4 5 6 7 8 9'
 ```
 ``` bnf
 octal-digit: one of
     '0 1 2 3 4 5 6 7'
 ```
 ``` bnf
 hexadecimal-digit: one of
     '0 1 2 3 4 5 6 7 8 9'
     'a b c d e f'
     'A B C D E F'
@@ -82,27 +96,31 @@ long-suffix: one of
 long-long-suffix: one of
     'll LL'
 ```
 An *integer literal* is a sequence of digits that has no period or
-exponent part. An integer literal may have a prefix that specifies its
-base and a suffix that specifies its type. The lexically first digit of
-the sequence of digits is the most significant. A *decimal* integer
-literal (base ten) begins with a digit other than `0` and consists of a
-sequence of decimal digits. An *octal* integer literal (base eight)
-begins with the digit `0` and consists of a sequence of octal
-digits.[^12] A *hexadecimal* integer literal (base sixteen) begins with
-`0x` or `0X` and consists of a sequence of hexadecimal digits, which
-include the decimal digits and the letters `a` through `f` and `A`
-through `F` with decimal values ten through fifteen. the number twelve
-can be written `12`, `014`, or `0XC`.
 The type of an integer literal is the first of the corresponding list in
-Table  [[tab:lex.type.integer.constant]] in which its value can be
 represented.
-**Table: Types of integer constants** <a id="tab:lex.type.integer.constant">[tab:lex.type.integer.constant]</a>
 |                  |                          |                          |
 | ---------------- | ------------------------ | ------------------------ |
 | none             | `int`                    | `int`                    |
 |                  | `long int`               | `unsigned int`           |
@@ -181,15 +199,18 @@ hexadecimal-escape-sequence:
 A character literal is one or more characters enclosed in single quotes,
 as in `'x'`, optionally preceded by one of the letters `u`, `U`, or `L`,
 as in `u'y'`, `U'z'`, or `L'x'`, respectively. A character literal that
 does not begin with `u`, `U`, or `L` is an ordinary character literal,
 also referred to as a narrow-character literal. An ordinary character
-literal that contains a single *c-char* has type `char`, with value
-equal to the numerical value of the encoding of the *c-char* in the
-execution character set. An ordinary character literal that contains
-more than one *c-char* is a *multicharacter literal*. A multicharacter
-literal has type `int` and *implementation-defined* value.
 A character literal that begins with the letter `u`, such as `u'y'`, is
 a character literal of type `char16_t`. The value of a `char16_t`
 literal containing a single *c-char* is equal to its ISO 10646 code
 point value, provided that the code point is representable with a single
@@ -291,35 +312,37 @@ sign: one of
 ```
 ``` bnf
 digit-sequence:
     digit
-    digit-sequence digit
 ```
 ``` bnf
 floating-suffix: one of
     'f l F L'
 ```
 A floating literal consists of an integer part, a decimal point, a
 fraction part, an `e` or `E`, 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. Either the integer part or the
-fraction part (not both) can be omitted; either the decimal point or the
-letter `e` (or `E` ) and the exponent (not both) can be omitted. The
-integer part, the optional decimal point and the optional fraction part
-form the *significant part* of the floating literal. The exponent, if
-present, indicates the power of 10 by which the significant part is to
-be scaled. 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.
 ### String literals <a id="lex.string">[[lex.string]]</a>
 ``` bnf
 string-literal:
@@ -412,18 +435,21 @@ is equivalent to `"\n)\?\?=\"\n"`.
 After translation phase 6, a string literal that does not begin with an
 *encoding-prefix* is an ordinary string literal, and is initialized with
 the given characters.
 A string literal that begins with `u8`, such as `u8"asdf"`, is a UTF-8
-string literal and is initialized with the given characters as encoded
-in UTF-8.
 Ordinary string literals and UTF-8 string literals are also referred to
 as narrow string literals. A narrow string literal has type “array of
 *n* `const char`”, where *n* is the size of the string as defined below,
 and has static storage duration ([[basic.stc]]).
 A string literal that begins with `u`, such as `u"asdf"`, is a
 `char16_t` string literal. A `char16_t` string literal has type “array
 of *n* `const char16_t`”, where *n* is the size of the string as defined
 below; it has static storage duration and is initialized with the given
 characters. A single *c-char* may produce more than one `char16_t`
@@ -448,18 +474,18 @@ In translation phase 6 ([[lex.phases]]), adjacent string literals are
 concatenated. If both string literals have the same *encoding-prefix*,
 the resulting concatenated string literal has that *encoding-prefix*. If
 one string literal has no *encoding-prefix*, it is treated as a string
 literal of the same *encoding-prefix* as the other operand. If a UTF-8
 string literal token is adjacent to a wide string literal token, the
-program is ill-formed. Any other concatenations are conditionally
-supported with *implementation-defined* behavior. This concatenation is
-an interpretation, not a conversion. Because the interpretation happens
-in translation phase 6 (after each character from a literal has been
-translated into a value from the appropriate character set), a string
-literal’s initial rawness has no effect on the interpretation or
-well-formedness of the concatenation. Table  [[tab:lex.string.concat]]
-has some examples of valid concatenations.
 **Table: String literal concatenations** <a id="tab:lex.string.concat">[tab:lex.string.concat]</a>
 |                            |       |                            |       |                            |       |
 | -------------------------- | ----- | -------------------------- | ----- | -------------------------- | ----- |
@@ -539,10 +565,11 @@ user-defined-literal:
 ``` bnf
 user-defined-integer-literal:
     decimal-literal ud-suffix
     octal-literal ud-suffix
     hexadecimal-literal ud-suffix
 ```
 ``` bnf
 user-defined-floating-literal:
     fractional-constant exponent-partₒₚₜ ud-suffix
@@ -587,11 +614,11 @@ call of the form
 operator "" X(nULL)
 ```
 Otherwise, *S* shall contain a raw literal operator or a literal
 operator template ([[over.literal]]) but not both. If *S* contains a
-raw literal operator, the *literal* *L* is treated as a call of the form
 ``` cpp
 operator "" X("n{"})
 ```
@@ -652,11 +679,11 @@ literal *L* is treated as a call of the form
 operator "" X(ch{})
 ```
 ``` cpp
 long double operator "" _w(long double);
-std::string operator "" _w(const char16_t*, size_t);
 unsigned operator "" _w(const char*);
 int main() {
   1.2_w;      // calls operator "" _w(1.2L)
   u"one"_w;   // calls operator "" _w(u"one", 3)
   12_w;       // calls operator "" _w("12")
@@ -688,10 +715,11 @@ standardization ([[usrlit.suffix]]). A program containing such a
 <!-- Link reference definitions -->
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.link]: basic.md#basic.link
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.stc]: basic.md#basic.stc
 [charname.allowed]: charname.md#charname.allowed
 [charname.disallowed]: charname.md#charname.disallowed
 [conv.mem]: conv.md#conv.mem
 [conv.ptr]: conv.md#conv.ptr
 [cpp]: cpp.md#cpp
@@ -730,11 +758,11 @@ standardization ([[usrlit.suffix]]). A program containing such a
 [tab:alternative.tokens]: #tab:alternative.tokens
 [tab:escape.sequences]: #tab:escape.sequences
 [tab:identifiers.special]: #tab:identifiers.special
 [tab:keywords]: #tab:keywords
 [tab:lex.string.concat]: #tab:lex.string.concat
-[tab:lex.type.integer.constant]: #tab:lex.type.integer.constant
 [tab:trigraph.sequences]: #tab:trigraph.sequences
 [temp.explicit]: temp.md#temp.explicit
 [temp.names]: temp.md#temp.names
 [usrlit.suffix]: library.md#usrlit.suffix

 ### Integer literals <a id="lex.icon">[[lex.icon]]</a>
 ``` bnf
 integer-literal:
+ binary-literal integer-suffixₒₚₜ
     octal-literal integer-suffixₒₚₜ
+    decimal-literal integer-suffixₒₚₜ
     hexadecimal-literal integer-suffixₒₚₜ
 ```
+``` bnf
+binary-literal:
+    '0b' binary-digit
+    '0B' binary-digit
+    binary-literal '''ₒₚₜ binary-digit
+```
+``` bnf
+octal-literal:
+    '0'
+    octal-literal '''ₒₚₜ octal-digit
+```
 ``` bnf
 decimal-literal:
     nonzero-digit
+    decimal-literal '''ₒₚₜ digit
 ```
 ``` bnf
 hexadecimal-literal:
     '0x' hexadecimal-digit
     '0X' hexadecimal-digit
+    hexadecimal-literal '''ₒₚₜ hexadecimal-digit
 ```
 ``` bnf
+binary-digit:
+    '0'
+    '1'
 ```
 ``` bnf
 octal-digit: one of
     '0 1 2 3 4 5 6 7'
 ```
+``` bnf
+nonzero-digit: one of
+    '1 2 3 4 5 6 7 8 9'
+```
 ``` bnf
 hexadecimal-digit: one of
     '0 1 2 3 4 5 6 7 8 9'
     'a b c d e f'
     'A B C D E F'
 long-long-suffix: one of
     'll LL'
 ```
 An *integer literal* is a sequence of digits that has no period or
+exponent part, with optional separating single quotes that are ignored
+when determining its value. An integer literal may have a prefix that
+specifies its base and a suffix that specifies its type. The lexically
+first digit of the sequence of digits is the most significant. A
+*binary* integer literal (base two) begins with `0b` or `0B` and
+consists of a sequence of binary digits. An *octal* integer literal
+(base eight) begins with the digit `0` and consists of a sequence of
+octal digits.[^12] A *decimal* integer literal (base ten) begins with a
+digit other than `0` and consists of a sequence of decimal digits. A
+*hexadecimal* integer literal (base sixteen) begins with `0x` or `0X`
+and consists of a sequence of hexadecimal digits, which include the
+decimal digits and the letters `a` through `f` and `A` through `F` with
+decimal values ten through fifteen. The number twelve can be written
+`12`, `014`, `0XC`, or `0b1100`. The literals `1048576`, `1'048'576`,
+`0X100000`, `0x10'0000`, and `0'004'000'000` all have the same value.
 The type of an integer literal is the first of the corresponding list in
+Table  [[tab:lex.type.integer.literal]] in which its value can be
 represented.
+**Table: Types of integer literals** <a id="tab:lex.type.integer.literal">[tab:lex.type.integer.literal]</a>
 |                  |                          |                          |
 | ---------------- | ------------------------ | ------------------------ |
 | none             | `int`                    | `int`                    |
 |                  | `long int`               | `unsigned int`           |
 A character literal is one or more characters enclosed in single quotes,
 as in `'x'`, optionally preceded by one of the letters `u`, `U`, or `L`,
 as in `u'y'`, `U'z'`, or `L'x'`, respectively. A character literal that
 does not begin with `u`, `U`, or `L` is an ordinary character literal,
 also referred to as a narrow-character literal. An ordinary character
+literal that contains a single *c-char* representable in the execution
+character set has type `char`, with value equal to the numerical value
+of the encoding of the *c-char* in the execution character set. An
+ordinary character literal that contains more than one *c-char* is a
+*multicharacter literal*. A multicharacter literal, or an ordinary
+character literal containing a single *c-char* not representable in the
+execution character set, is conditionally-supported, has type `int`, and
+has an *implementation-defined* value.
 A character literal that begins with the letter `u`, such as `u'y'`, is
 a character literal of type `char16_t`. The value of a `char16_t`
 literal containing a single *c-char* is equal to its ISO 10646 code
 point value, provided that the code point is representable with a single
 ```
 ``` bnf
 digit-sequence:
     digit
+    digit-sequence '''ₒₚₜ digit
 ```
 ``` bnf
 floating-suffix: one of
     'f l F L'
 ```
 A floating literal consists of an integer part, a decimal point, a
 fraction part, an `e` or `E`, 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. Optional separating single
+quotes in a *digit-sequence* are ignored when determining its value. The
+literals `1.602'176'565e-19` and `1.602176565e-19` have the same value.
+Either the integer part or the fraction part (not both) can be omitted;
+either the decimal point or the letter `e` (or `E` ) and the exponent
+(not both) can be omitted. The integer part, the optional decimal point
+and the optional fraction part form the *significant part* of the
+floating literal. The exponent, if present, indicates the power of 10 by
+which the significant part is to be scaled. 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.
 ### String literals <a id="lex.string">[[lex.string]]</a>
 ``` bnf
 string-literal:
 After translation phase 6, a string literal that does not begin with an
 *encoding-prefix* is an ordinary string literal, and is initialized with
 the given characters.
 A string literal that begins with `u8`, such as `u8"asdf"`, is a UTF-8
+string literal.
 Ordinary string literals and UTF-8 string literals are also referred to
 as narrow string literals. A narrow string literal has type “array of
 *n* `const char`”, where *n* is the size of the string as defined below,
 and has static storage duration ([[basic.stc]]).
+For a UTF-8 string literal, each successive element of the object
+representation ([[basic.types]]) has the value of the corresponding
+code unit of the UTF-8 encoding of the string.
 A string literal that begins with `u`, such as `u"asdf"`, is a
 `char16_t` string literal. A `char16_t` string literal has type “array
 of *n* `const char16_t`”, where *n* is the size of the string as defined
 below; it has static storage duration and is initialized with the given
 characters. A single *c-char* may produce more than one `char16_t`
 concatenated. If both string literals have the same *encoding-prefix*,
 the resulting concatenated string literal has that *encoding-prefix*. If
 one string literal has no *encoding-prefix*, it is treated as a string
 literal of the same *encoding-prefix* as the other operand. If a UTF-8
 string literal token is adjacent to a wide string literal token, the
+program is ill-formed. Any other concatenations are
+conditionally-supported with *implementation-defined* behavior. This
+concatenation is an interpretation, not a conversion. Because the
+interpretation happens in translation phase 6 (after each character from
+a literal has been translated into a value from the appropriate
+character set), a string literal’s initial rawness has no effect on the
+interpretation or well-formedness of the concatenation. Table
+[[tab:lex.string.concat]] has some examples of valid concatenations.
 **Table: String literal concatenations** <a id="tab:lex.string.concat">[tab:lex.string.concat]</a>
 |                            |       |                            |       |                            |       |
 | -------------------------- | ----- | -------------------------- | ----- | -------------------------- | ----- |
 ``` bnf
 user-defined-integer-literal:
     decimal-literal ud-suffix
     octal-literal ud-suffix
     hexadecimal-literal ud-suffix
+    binary-literal ud-suffix
 ```
 ``` bnf
 user-defined-floating-literal:
     fractional-constant exponent-partₒₚₜ ud-suffix
 operator "" X(nULL)
 ```
 Otherwise, *S* shall contain a raw literal operator or a literal
 operator template ([[over.literal]]) but not both. If *S* contains a
+raw literal operator, the literal *L* is treated as a call of the form
 ``` cpp
 operator "" X("n{"})
 ```
 operator "" X(ch{})
 ```
 ``` cpp
 long double operator "" _w(long double);
+std::string operator "" _w(const char16_t*, std::size_t);
 unsigned operator "" _w(const char*);
 int main() {
   1.2_w;      // calls operator "" _w(1.2L)
   u"one"_w;   // calls operator "" _w(u"one", 3)
   12_w;       // calls operator "" _w("12")
 <!-- Link reference definitions -->
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.link]: basic.md#basic.link
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.stc]: basic.md#basic.stc
+[basic.types]: basic.md#basic.types
 [charname.allowed]: charname.md#charname.allowed
 [charname.disallowed]: charname.md#charname.disallowed
 [conv.mem]: conv.md#conv.mem
 [conv.ptr]: conv.md#conv.ptr
 [cpp]: cpp.md#cpp
 [tab:alternative.tokens]: #tab:alternative.tokens
 [tab:escape.sequences]: #tab:escape.sequences
 [tab:identifiers.special]: #tab:identifiers.special
 [tab:keywords]: #tab:keywords
 [tab:lex.string.concat]: #tab:lex.string.concat
+[tab:lex.type.integer.literal]: #tab:lex.type.integer.literal
 [tab:trigraph.sequences]: #tab:trigraph.sequences
 [temp.explicit]: temp.md#temp.explicit
 [temp.names]: temp.md#temp.names
 [usrlit.suffix]: library.md#usrlit.suffix

Diff to HTML by rtfpessoa