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

Files changed (1) hide show

tmp/tmpk1cv93wi/{from.md → to.md} +108 -77

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

@@ -38,17 +38,18 @@ following phases.[^1]
     notation), are handled equivalently except where this replacement is
     reverted in a raw string literal.)
 2.  Each instance of a backslash character (\\ immediately followed by a
     new-line character is deleted, splicing physical source lines to
     form logical source lines. Only the last backslash on any physical
-    source line shall be eligible for being part of such a splice. If,
- as a result, a character sequence that matches the syntax of a
- universal-character-name is produced, the behavior is undefined. A
- source file that is not empty and that does not end in a new-line
- character, or that ends in a new-line character immediately preceded
- by a backslash character before any such splicing takes place, shall
- be processed as if an additional new-line character were appended to
     the file.
 3.  The source file is decomposed into preprocessing tokens (
     [[lex.pptoken]]) and sequences of white-space characters (including
     comments). A source file shall not end in a partial preprocessing
     token or in a partial comment.[^2] Each comment is replaced by one
@@ -117,11 +118,11 @@ a b c d e f g h i j k l m n o p q r s t u v w x y z
 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 0 1 2 3 4 5 6 7 8 9
-_ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | \sim ! = , \" '
 ```
 The *universal-character-name* construct provides a way to name other
 characters.
@@ -293,16 +294,16 @@ characters.
 ## Comments <a id="lex.comment">[[lex.comment]]</a>
 The characters `/*` start a comment, which terminates with the
 characters `*/`. These comments do not nest. The characters `//` start a
-comment, which terminates with the next new-line character. If there is
-a form-feed or a vertical-tab character in such a comment, only
-white-space characters shall appear between it and the new-line that
-terminates the comment; no diagnostic is required. The comment
-characters `//`, `/*`, and `*/` have no special meaning within a `//`
-comment and are treated just like other characters. Similarly, the
 comment characters `//` and `/*` have no special meaning within a `/*`
 comment.
 ## Header names <a id="lex.header">[[lex.header]]</a>
@@ -340,11 +341,11 @@ of *header-name*s are mapped in an *implementation-defined* manner to
 headers or to external source file names as specified in
 [[cpp.include]].
 The appearance of either of the characters `'` or `\` or of either of
 the character sequences `/*` or `//` in a *q-char-sequence* or an
-*h-char-sequence* is conditionally supported with implementation-defined
 semantics, as is the appearance of the character `"` in an
 *h-char-sequence*.[^9]
 ## Preprocessing numbers <a id="lex.ppnumber">[[lex.ppnumber]]</a>
@@ -352,20 +353,22 @@ semantics, as is the appearance of the character `"` in an
 pp-number:
     digit
     '.' digit
     pp-number digit
     pp-number identifier-nondigit
     pp-number 'e' sign
     pp-number 'E' sign
     pp-number '.'
 ```
-Preprocessing number tokens lexically include all integral literal
 tokens ([[lex.icon]]) and all floating literal tokens ([[lex.fcon]]).
 A preprocessing number does not have a type or a value; it acquires both
-after a successful conversion to an integral literal token or a floating
 literal token.
 ## Identifiers <a id="lex.name">[[lex.name]]</a>
 ``` bnf
@@ -404,13 +407,13 @@ into one of the ranges specified in  [[charname.disallowed]]. Upper- and
 lower-case letters are different. All characters are significant.[^10]
 The identifiers in Table  [[tab:identifiers.special]] have a special
 meaning when appearing in a certain context. When referred to in the
 grammar, these identifiers are used explicitly rather than using the
-*identifier* grammar production. any ambiguity as to whether a given
-*identifier* has a special meaning is resolved to interpret the token as
-a regular *identifier*.
 **Table: Identifiers with special meaning** <a id="tab:identifiers.special">[tab:identifiers.special]</a>
 |            |         |
 | ---------- | ------- |
@@ -489,44 +492,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'
@@ -554,27 +571,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`           |
@@ -653,15 +674,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
@@ -763,35 +787,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:
@@ -884,18 +910,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`
@@ -920,18 +949,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>
 |                            |       |                            |       |                            |       |
 | -------------------------- | ----- | -------------------------- | ----- | -------------------------- | ----- |
@@ -1011,10 +1040,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
@@ -1059,11 +1089,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{"})
 ```
@@ -1124,11 +1154,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")
@@ -1160,10 +1190,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
@@ -1202,11 +1233,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

     notation), are handled equivalently except where this replacement is
     reverted in a raw string literal.)
 2.  Each instance of a backslash character (\\ immediately followed by a
     new-line character is deleted, splicing physical source lines to
     form logical source lines. Only the last backslash on any physical
+    source line shall be eligible for being part of such a splice.
+ Except for splices reverted in a raw string literal, if a splice
+ results in a character sequence that matches the syntax of a
+ universal-character-name, the behavior is undefined. A source file
+ that is not empty and that does not end in a new-line character, or
+ that ends in a new-line character immediately preceded by a
+ backslash character before any such splicing takes place, shall be
+    processed as if an additional new-line character were appended to
     the file.
 3.  The source file is decomposed into preprocessing tokens (
     [[lex.pptoken]]) and sequences of white-space characters (including
     comments). A source file shall not end in a partial preprocessing
     token or in a partial comment.[^2] Each comment is replaced by one
 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 0 1 2 3 4 5 6 7 8 9
+_ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | ~ ! = , \" '
 ```
 The *universal-character-name* construct provides a way to name other
 characters.
 ## Comments <a id="lex.comment">[[lex.comment]]</a>
 The characters `/*` start a comment, which terminates with the
 characters `*/`. These comments do not nest. The characters `//` start a
+comment, which terminates immediately before the next new-line
+character. If there is a form-feed or a vertical-tab character in such a
+comment, only white-space characters shall appear between it and the
+new-line that terminates the comment; no diagnostic is required. The
+comment characters `//`, `/*`, and `*/` have no special meaning within a
+`//` comment and are treated just like other characters. Similarly, the
 comment characters `//` and `/*` have no special meaning within a `/*`
 comment.
 ## Header names <a id="lex.header">[[lex.header]]</a>
 headers or to external source file names as specified in
 [[cpp.include]].
 The appearance of either of the characters `'` or `\` or of either of
 the character sequences `/*` or `//` in a *q-char-sequence* or an
+*h-char-sequence* is conditionally-supported with implementation-defined
 semantics, as is the appearance of the character `"` in an
 *h-char-sequence*.[^9]
 ## Preprocessing numbers <a id="lex.ppnumber">[[lex.ppnumber]]</a>
 pp-number:
     digit
     '.' digit
     pp-number digit
     pp-number identifier-nondigit
+    pp-number ''' digit
+    pp-number ''' nondigit
     pp-number 'e' sign
     pp-number 'E' sign
     pp-number '.'
 ```
+Preprocessing number tokens lexically include all integer literal
 tokens ([[lex.icon]]) and all floating literal tokens ([[lex.fcon]]).
 A preprocessing number does not have a type or a value; it acquires both
+after a successful conversion to an integer literal token or a floating
 literal token.
 ## Identifiers <a id="lex.name">[[lex.name]]</a>
 ``` bnf
 lower-case letters are different. All characters are significant.[^10]
 The identifiers in Table  [[tab:identifiers.special]] have a special
 meaning when appearing in a certain context. When referred to in the
 grammar, these identifiers are used explicitly rather than using the
+*identifier* grammar production. Unless otherwise specified, any
+ambiguity as to whether a given *identifier* has a special meaning is
+resolved to interpret the token as a regular *identifier*.
 **Table: Identifiers with special meaning** <a id="tab:identifiers.special">[tab:identifiers.special]</a>
 |            |         |
 | ---------- | ------- |
 ### 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