cplusplus:

::= preprocessing-file? translation-unit

no referencesnamed-universal-character:

::= '\N{' '{any member of the translation character set except the \unicode{007d}{right curly bracket} or new-line character}'+ '}'

referenced by: universal-character-name hex-quad:

hex-quad ::= hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit

referenced by: universal-character-name simple-hexadecimal-digit-sequence:

simple-hexadecimal-digit-sequence

::= hexadecimal-digit+

referenced by: hexadecimal-escape-sequence universal-character-name universal-character-name:

universal-character-name

::= ( '\u' | '\U' hex-quad ) hex-quad

| '\u{' simple-hexadecimal-digit-sequence '}'

| named-universal-character

referenced by: c-char s-char preprocessing-token:

preprocessing-token

::= header-name

| 'import'

| 'module'

| 'export'

| identifier

| '.'? digit ( identifier-continue | "'" ( digit | nondigit ) | ( 'e' | 'E' | 'p' | 'P' ) sign | '.' )*

| character-literal

| user-defined-character-literal

| string-literal

| user-defined-string-literal

| preprocessing-op-or-punc

| '{each non-whitespace character that cannot be one of the above}'

referenced by: pp-tokens header-name:

header-name

::= '<' '{any member of the translation character set except new-line and \unicode{003e}{greater-than sign}}'+ '>'

| '"' '{any member of the translation character set except new-line and \unicode{0022}{quotation mark}}'+ '"'

referenced by: has-include-expression module-import-declaration pp-import preprocessing-token identifier:

identifier

::= identifier-start identifier-continue*

referenced by: alias-declaration attribute-namespace attribute-scoped-token attribute-token cast-expression class-name concept-name control-line defined-macro-expression designator elaborated-type-specifier elif-group enum-head-name enum-name enumerator identifier-list if-group init-capture jump-statement label literal-operator-id mem-initializer-id member-declarator module-name module-name-qualifier module-partition named-namespace-definition namespace-alias namespace-alias-definition namespace-name nested-name-specifier nested-namespace-definition preprocessing-token simple-capture template-name type-parameter typedef-name typename-specifier ud-suffix unqualified-id using-enum-declarator identifier-start:

identifier-start

::= nondigit

| '{an element of the translation character set with the Unicode property XID_Start}'

referenced by: identifier identifier-continue:

identifier-continue

::= digit

| nondigit

| '{an element of the translation character set with the Unicode property XID_Continue}'

referenced by: identifier preprocessing-token nondigit:

nondigit ::= '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'

| '_'

referenced by: identifier-continue identifier-start preprocessing-token digit:

digit ::= '0'

| '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

| '8'

| '9'

referenced by: decimal-literal digit-sequence identifier-continue preprocessing-token keyword:

keyword ::= '{any identifier listed in lex.key}'

| 'import'

| 'module'

| 'export'

no referencespreprocessing-op-or-punc:

preprocessing-op-or-punc

::= preprocessing-operator

| operator-or-punctuator

referenced by: preprocessing-token preprocessing-operator:

preprocessing-operator

::= '#'

| '##'

| '%:'

| '%:%:'

referenced by: preprocessing-op-or-punc operator-or-punctuator:

operator-or-punctuator

::= '{'

| '}'

| '['

| ']'

| '('

| ')'

| '<:'

| ':>'

| '<%'

| '%>'

| ';'

| ':'

| '...'

| '?'

| '::'

| '.'

| '.*'

| '->'

| '->*'

| '~'

| '!'

| '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '='

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '=='

| '!='

| '<'

| '>'

| '<='

| '>='

| '<=>'

| '&&'

| '||'

| '<<'

| '>>'

| '<<='

| '>>='

| '++'

| '--'

| ','

| 'and'

| 'or'

| 'xor'

| 'not'

| 'bitand'

| 'bitor'

| 'compl'

| 'and_eq'

| 'or_eq'

| 'xor_eq'

| 'not_eq'

referenced by: preprocessing-op-or-punc literal:

literal ::= integer-literal

| character-literal

| floating-point-literal

| string-literal

| boolean-literal

| 'nullptr'

| user-defined-literal

referenced by: primary-expression integer-literal:

integer-literal

::= ( binary-literal | octal-literal | decimal-literal | hexadecimal-literal ) integer-suffix?

referenced by: literal binary-literal:

binary-literal

::= ( '0b' | '0B' ) binary-digit ( "'"? binary-digit )*

referenced by: integer-literal user-defined-integer-literal octal-literal:

octal-literal

::= '0' ( "'"? octal-digit )*

referenced by: integer-literal user-defined-integer-literal decimal-literal:

decimal-literal

::= nonzero-digit ( "'"? digit )*

referenced by: integer-literal user-defined-integer-literal hexadecimal-literal:

hexadecimal-literal

::= hexadecimal-prefix hexadecimal-digit-sequence

referenced by: integer-literal user-defined-integer-literal binary-digit:

binary-digit

::= '0'

| '1'

referenced by: binary-literal octal-digit:

octal-digit

::= '0'

| '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

referenced by: octal-escape-sequence octal-literal nonzero-digit:

nonzero-digit

::= '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

| '8'

| '9'

referenced by: decimal-literal hexadecimal-prefix:

hexadecimal-prefix

::= '0x'

| '0X'

referenced by: hexadecimal-floating-point-literal hexadecimal-literal user-defined-floating-point-literal hexadecimal-digit-sequence:

hexadecimal-digit-sequence

::= hexadecimal-digit ( "'"? hexadecimal-digit )*

referenced by: hexadecimal-floating-point-literal hexadecimal-fractional-constant hexadecimal-literal user-defined-floating-point-literal hexadecimal-digit:

hexadecimal-digit

::= '0'

| '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

| '8'

| '9'

| 'a'

| 'b'

| 'c'

| 'd'

| 'e'

| 'f'

| 'A'

| 'B'

| 'C'

| 'D'

| 'E'

| 'F'

referenced by: hex-quad hexadecimal-digit-sequence simple-hexadecimal-digit-sequence integer-suffix:

integer-suffix

::= unsigned-suffix ( long-suffix | long-long-suffix | size-suffix )?

| ( long-suffix | long-long-suffix | size-suffix ) unsigned-suffix?

referenced by: integer-literal unsigned-suffix:

unsigned-suffix

::= 'u'

| 'U'

referenced by: integer-suffix long-suffix:

long-suffix

::= 'l'

| 'L'

referenced by: integer-suffix long-long-suffix:

long-long-suffix

::= 'll'

| 'LL'

referenced by: integer-suffix size-suffix:

size-suffix

::= 'z'

| 'Z'

referenced by: integer-suffix character-literal:

character-literal

::= encoding-prefix? "'" c-char+ "'"

referenced by: literal preprocessing-token user-defined-character-literal encoding-prefix:

encoding-prefix

::= 'u8'

| 'u'

| 'U'

| 'L'

referenced by: character-literal string-literal c-char:

c-char ::= basic-c-char

| escape-sequence

| universal-character-name

referenced by: character-literal basic-c-char:

basic-c-char

::= '{any member of the translation character set except the \unicode{0027}{apostrophe},}' '{\unicode{005c}{reverse solidus}, or new-line character}'

referenced by: c-char escape-sequence:

escape-sequence

::= simple-escape-sequence

| numeric-escape-sequence

| conditional-escape-sequence

referenced by: c-char s-char simple-escape-sequence:

simple-escape-sequence

::= '\' simple-escape-sequence-char

referenced by: escape-sequence simple-escape-sequence-char:

simple-escape-sequence-char

::= "'"

| '"'

| '?'

| '\'

| 'a'

| 'b'

| 'f'

| 'n'

| 'r'

| 't'

| 'v'

referenced by: simple-escape-sequence numeric-escape-sequence:

numeric-escape-sequence

::= octal-escape-sequence

| hexadecimal-escape-sequence

referenced by: escape-sequence octal-escape-sequence:

octal-escape-sequence

::= '\' octal-digit ( octal-digit octal-digit? )?

| '\o{' octal-digit+ '}'

referenced by: numeric-escape-sequence hexadecimal-escape-sequence:

hexadecimal-escape-sequence

::= '\x' simple-hexadecimal-digit-sequence

| '\x{' simple-hexadecimal-digit-sequence '}'

referenced by: numeric-escape-sequence conditional-escape-sequence:

conditional-escape-sequence

::= '\' '{any member of the basic character set that is not an octal-digit, a simple-escape-sequence-char, or the characters "N", "o", "u", "U", or "x"}'

referenced by: escape-sequence floating-point-literal:

floating-point-literal

::= decimal-floating-point-literal

| hexadecimal-floating-point-literal

referenced by: literal decimal-floating-point-literal:

decimal-floating-point-literal

::= ( fractional-constant exponent-part? | digit-sequence exponent-part ) floating-point-suffix?

referenced by: floating-point-literal hexadecimal-floating-point-literal:

hexadecimal-floating-point-literal

::= hexadecimal-prefix ( hexadecimal-fractional-constant | hexadecimal-digit-sequence ) binary-exponent-part floating-point-suffix?

referenced by: floating-point-literal fractional-constant:

fractional-constant

::= digit-sequence? '.' digit-sequence

| digit-sequence '.'

referenced by: decimal-floating-point-literal user-defined-floating-point-literal hexadecimal-fractional-constant:

hexadecimal-fractional-constant

::= hexadecimal-digit-sequence? '.' hexadecimal-digit-sequence

| hexadecimal-digit-sequence '.'

referenced by: hexadecimal-floating-point-literal user-defined-floating-point-literal exponent-part:

exponent-part

::= ( 'e' | 'E' ) sign? digit-sequence

referenced by: decimal-floating-point-literal user-defined-floating-point-literal binary-exponent-part:

binary-exponent-part

::= ( 'p' | 'P' ) sign? digit-sequence

referenced by: hexadecimal-floating-point-literal user-defined-floating-point-literal sign:

sign ::= '+'

| '-'

referenced by: binary-exponent-part exponent-part preprocessing-token digit-sequence:

digit-sequence

::= digit ( "'"? digit )*

referenced by: binary-exponent-part decimal-floating-point-literal exponent-part fractional-constant user-defined-floating-point-literal floating-point-suffix:

floating-point-suffix

::= 'f'

| 'l'

| 'f16'

| 'f32'

| 'f64'

| 'f128'

| 'bf16'

| 'F'

| 'L'

| 'F16'

| 'F32'

| 'F64'

| 'F128'

| 'BF16'

referenced by: decimal-floating-point-literal hexadecimal-floating-point-literal string-literal:

string-literal

::= encoding-prefix? ( '"' s-char* '"' | 'R' raw-string )

referenced by: header-name-tokens literal preprocessing-token unevaluated-string user-defined-string-literal s-char:

s-char ::= basic-s-char

| escape-sequence

| universal-character-name

referenced by: string-literal basic-s-char:

basic-s-char

::= '{any member of the translation character set except the \unicode{0022}{quotation mark},}' '{\unicode{005c}{reverse solidus}, or new-line character}'

referenced by: s-char raw-string:

raw-string

::= '"' d-char-sequence? '(' r-char* ')' d-char-sequence? '"'

referenced by: string-literal r-char:

r-char ::= '{any member of the translation character set, except a \unicode{0029}{right parenthesis} followed by}' '{the initial d-char-sequence (which may be empty) followed by a \unicode{0022}{quotation mark}}'

referenced by: raw-string d-char-sequence:

d-char-sequence

::= d-char+

referenced by: raw-string d-char:

d-char ::= '{any member of the basic character set except:}' '{\unicode{0020}{space}, \unicode{0028}{left parenthesis}, \unicode{0029}{right parenthesis}, \unicode{005c}{reverse solidus},}' '{\unicode{0009}{character tabulation}, \unicode{000b}{line tabulation}, \unicode{000c}{form feed}, and new-line}'

referenced by: d-char-sequence unevaluated-string:

unevaluated-string

::= string-literal

referenced by: linkage-specification literal-operator-id static_assert-message boolean-literal:

boolean-literal

::= 'false'

| 'true'

referenced by: literal user-defined-literal:

user-defined-literal

::= user-defined-integer-literal

| user-defined-floating-point-literal

| user-defined-string-literal

| user-defined-character-literal

referenced by: literal user-defined-integer-literal:

user-defined-integer-literal

::= ( decimal-literal | octal-literal | hexadecimal-literal | binary-literal ) ud-suffix

referenced by: user-defined-literal user-defined-floating-point-literal:

user-defined-floating-point-literal

::= ( fractional-constant exponent-part? | digit-sequence exponent-part | hexadecimal-prefix ( hexadecimal-fractional-constant | hexadecimal-digit-sequence ) binary-exponent-part ) ud-suffix

referenced by: user-defined-literal user-defined-string-literal:

user-defined-string-literal

::= string-literal ud-suffix

referenced by: literal-operator-id preprocessing-token user-defined-literal user-defined-character-literal:

user-defined-character-literal

::= character-literal ud-suffix

referenced by: preprocessing-token user-defined-literal ud-suffix:

ud-suffix

::= identifier

referenced by: user-defined-character-literal user-defined-floating-point-literal user-defined-integer-literal user-defined-string-literal translation-unit:

translation-unit

::= ( declaration-seq | global-module-fragment? module-declaration declaration-seq? private-module-fragment? )?

referenced by: cplusplus primary-expression:

primary-expression

::= literal

| 'this'

| '(' expression ')'

| id-expression

| lambda-expression

| fold-expression

| requires-expression

referenced by: cast-expression constraint-logical-and-expression id-expression:

id-expression

::= unqualified-id

| qualified-id

| pack-index-expression

referenced by: cast-expression declarator-id pack-index-expression primary-expression template-argument type-parameter unqualified-id:

unqualified-id

::= identifier

| operator-function-id

| conversion-function-id

| literal-operator-id

| '~' ( type-name | computed-type-specifier )

| template-id

referenced by: id-expression qualified-id using-declarator qualified-id:

qualified-id

::= nested-name-specifier 'template'? unqualified-id

referenced by: id-expression nested-name-specifier:

nested-name-specifier

::= ( type-name | namespace-name | computed-type-specifier )? '::' ( ( identifier | 'template'? simple-template-id ) '::' )*

referenced by: class-head-name class-or-decltype elaborated-type-specifier enum-head-name ptr-operator qualified-id qualified-namespace-specifier simple-type-specifier type-constraint type-requirement typename-specifier using-declarator using-directive using-enum-declarator pack-index-expression:

pack-index-expression

::= id-expression '...' '[' constant-expression ']'

referenced by: id-expression lambda-expression:

lambda-expression

::= lambda-introducer ( '<' template-parameter-list '>' requires-clause? )? attribute-specifier-seq? lambda-declarator compound-statement

referenced by: primary-expression lambda-introducer:

lambda-introducer

::= '[' lambda-capture? ']'

referenced by: lambda-expression lambda-declarator:

lambda-declarator

::= ( ( lambda-specifier-seq noexcept-specifier? | noexcept-specifier ) attribute-specifier-seq? )? trailing-return-type?

| '(' parameter-declaration-clause ')' lambda-specifier-seq? noexcept-specifier? attribute-specifier-seq? trailing-return-type? requires-clause?

referenced by: lambda-expression lambda-specifier:

lambda-specifier

::= 'consteval'

| 'constexpr'

| 'mutable'

| 'static'

referenced by: lambda-specifier-seq lambda-specifier-seq:

lambda-specifier-seq

::= lambda-specifier+

referenced by: lambda-declarator lambda-capture:

lambda-capture

::= capture-default ( ',' capture-list )?

| capture-list

referenced by: lambda-introducer capture-default:

capture-default

::= '&'

| '='

referenced by: lambda-capture capture-list:

capture-list

::= capture ( ',' capture )*

referenced by: lambda-capture capture:

capture ::= simple-capture

| init-capture

referenced by: capture-list simple-capture:

simple-capture

::= '&'? identifier '...'?

| '*'? 'this'

referenced by: capture init-capture:

init-capture

::= '&'? '...'? identifier initializer

referenced by: capture fold-expression:

fold-expression

::= '(' ( cast-expression fold-operator '...' ( fold-operator cast-expression )? | '...' fold-operator cast-expression ) ')'

referenced by: primary-expression fold-operator:

fold-operator

::= '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '<<'

| '>>'

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '<<='

| '>>='

| '='

| '=='

| '!='

| '<'

| '>'

| '<='

| '>='

| '&&'

| '||'

| ','

| '.*'

| '->*'

referenced by: fold-expression requires-expression:

requires-expression

::= 'requires' requirement-parameter-list? requirement-body

referenced by: primary-expression requirement-parameter-list:

requirement-parameter-list

::= '(' parameter-declaration-clause ')'

referenced by: requires-expression requirement-body:

requirement-body

::= '{' requirement+ '}'

referenced by: requires-expression requirement:

requirement

::= simple-requirement

| type-requirement

| compound-requirement

| nested-requirement

referenced by: requirement-body simple-requirement:

simple-requirement

::= expression ';'

referenced by: requirement type-requirement:

type-requirement

::= 'typename' nested-name-specifier? type-name ';'

referenced by: requirement compound-requirement:

compound-requirement

::= '{' expression '}' 'noexcept'? return-type-requirement? ';'

referenced by: requirement return-type-requirement:

return-type-requirement

::= '->' type-constraint

referenced by: compound-requirement nested-requirement:

nested-requirement

::= 'requires' constraint-expression ';'

referenced by: requirement expression-list:

expression-list

::= initializer-list

referenced by: cast-expression initializer mem-initializer new-initializer new-placement unary-operator:

unary-operator

::= '*'

| '&'

| '+'

| '-'

| '!'

| '~'

referenced by: cast-expression await-expression:

await-expression

::= 'co_await' cast-expression

referenced by: cast-expression noexcept-expression:

noexcept-expression

::= 'noexcept' '(' expression ')'

referenced by: cast-expression new-expression:

new-expression

::= '::'? 'new' new-placement? ( new-type-id | '(' type-id ')' ) new-initializer?

referenced by: cast-expression new-placement:

new-placement

::= '(' expression-list ')'

referenced by: new-expression new-type-id:

new-type-id

::= type-specifier-seq ( ptr-operator* ( ptr-operator | '[' expression? ']' attribute-specifier-seq? ( '[' constant-expression ']' attribute-specifier-seq? )* ) )?

referenced by: new-expression new-initializer:

new-initializer

::= '(' expression-list? ')'

| braced-init-list

referenced by: new-expression delete-expression:

delete-expression

::= '::'? 'delete' ( '[' ']' )? cast-expression

referenced by: cast-expression cast-expression:

cast-expression

referenced by: await-expression cast-expression delete-expression fold-expression pm-expression pm-expression:

pm-expression

::= cast-expression ( ( '.*' | '->*' ) cast-expression )*

referenced by: multiplicative-expression multiplicative-expression:

multiplicative-expression

::= pm-expression ( ( '*' | '/' | '%' ) pm-expression )*

referenced by: additive-expression additive-expression:

additive-expression

::= multiplicative-expression ( ( '+' | '-' ) multiplicative-expression )*

referenced by: shift-expression shift-expression:

shift-expression

::= additive-expression ( ( '<<' | '>>' ) additive-expression )*

referenced by: compare-expression compare-expression:

compare-expression

::= shift-expression ( '<=>' shift-expression )*

referenced by: relational-expression relational-expression:

relational-expression

::= compare-expression ( ( '<' | '>' | '<=' | '>=' ) compare-expression )*

referenced by: equality-expression equality-expression:

equality-expression

::= relational-expression ( ( '==' | '!=' ) relational-expression )*

referenced by: and-expression and-expression:

and-expression

::= equality-expression ( '&' equality-expression )*

referenced by: exclusive-or-expression exclusive-or-expression:

exclusive-or-expression

::= and-expression ( '^' and-expression )*

referenced by: inclusive-or-expression inclusive-or-expression:

inclusive-or-expression

::= exclusive-or-expression ( '|' exclusive-or-expression )*

referenced by: logical-and-expression logical-and-expression:

logical-and-expression

::= inclusive-or-expression ( '&&' inclusive-or-expression )*

referenced by: logical-or-expression logical-or-expression:

logical-or-expression

::= logical-and-expression ( '||' logical-and-expression )*

referenced by: assignment-expression conditional-expression constraint-expression conditional-expression:

conditional-expression

::= logical-or-expression ( '?' expression ':' assignment-expression )?

referenced by: assignment-expression constant-expression yield-expression:

yield-expression

::= 'co_yield' ( assignment-expression | braced-init-list )

referenced by: assignment-expression throw-expression:

throw-expression

::= 'throw' assignment-expression?

referenced by: assignment-expression assignment-expression:

assignment-expression

::= conditional-expression

| yield-expression

| throw-expression

| logical-or-expression assignment-operator initializer-clause

referenced by: conditional-expression expression initializer-clause throw-expression yield-expression assignment-operator:

assignment-operator

::= '='

| '*='

| '/='

| '%='

| '+='

| '-='

| '>>='

| '<<='

| '&='

| '^='

| '|='

referenced by: assignment-expression expression:

expression

::= assignment-expression ( ',' assignment-expression )*

referenced by: cast-expression compound-requirement condition conditional-expression decltype-specifier expr-or-braced-init-list expression-statement iteration-statement new-type-id noexcept-expression primary-expression simple-requirement constant-expression:

constant-expression

::= conditional-expression

referenced by: alignment-specifier elif-group enumerator-definition explicit-specifier if-group label member-declarator new-type-id noexcept-specifier noptr-abstract-declarator noptr-declarator pack-index-expression pack-index-specifier static_assert-declaration static_assert-message template-argument statement:

statement

::= labeled-statement

| declaration-statement

referenced by: compound-statement iteration-statement labeled-statement selection-statement init-statement:

init-statement

::= expression-statement

| simple-declaration

| alias-declaration

referenced by: iteration-statement selection-statement condition:

condition

::= expression

| attribute-specifier-seq? decl-specifier-seq declarator brace-or-equal-initializer

referenced by: iteration-statement selection-statement label:

label ::= attribute-specifier-seq? ( identifier | 'case' constant-expression | 'default' ) ':'

referenced by: compound-statement labeled-statement labeled-statement:

labeled-statement

::= label statement

referenced by: statement expression-statement:

expression-statement

::= expression? ';'

referenced by: init-statement statement compound-statement:

compound-statement

::= '{' statement* label* '}'

referenced by: function-body function-try-block handler lambda-expression selection-statement statement try-block selection-statement:

selection-statement

::= 'if' ( 'constexpr'? '(' init-statement? condition ')' statement | '!'? 'consteval' compound-statement ) ( 'else' statement )?

| 'switch' '(' init-statement? condition ')' statement

referenced by: statement iteration-statement:

iteration-statement

::= ( 'while' '(' condition | 'for' '(' ( init-statement condition? ';' expression? | init-statement? for-range-declaration ':' for-range-initializer ) ) ')' statement

| 'do' statement 'while' '(' expression ')' ';'

referenced by: statement for-range-declaration:

for-range-declaration

::= attribute-specifier-seq? decl-specifier-seq ( declarator | ref-qualifier? '[' identifier-list ']' )

referenced by: iteration-statement for-range-initializer:

for-range-initializer

::= expr-or-braced-init-list

referenced by: iteration-statement jump-statement:

jump-statement

::= ( 'break' | 'continue' | 'return' expr-or-braced-init-list? | 'goto' identifier ) ';'

| coroutine-return-statement

referenced by: statement coroutine-return-statement:

coroutine-return-statement

::= 'co_return' expr-or-braced-init-list? ';'

referenced by: jump-statement declaration-statement:

declaration-statement

::= block-declaration

referenced by: statement declaration-seq:

declaration-seq

::= declaration+

referenced by: export-declaration global-module-fragment linkage-specification namespace-body private-module-fragment translation-unit declaration:

declaration

::= name-declaration

| special-declaration

referenced by: declaration-seq explicit-instantiation explicit-specialization template-declaration name-declaration:

name-declaration

::= block-declaration

| nodeclspec-function-declaration

| function-definition

| template-declaration

| deduction-guide

| linkage-specification

| namespace-definition

| ';'

| attribute-declaration

| module-import-declaration

referenced by: declaration export-declaration linkage-specification special-declaration:

special-declaration

::= explicit-instantiation

| explicit-specialization

| export-declaration

referenced by: declaration block-declaration:

block-declaration

::= simple-declaration

| asm-declaration

| namespace-alias-definition

| using-declaration

| using-enum-declaration

| using-directive

| static_assert-declaration

| alias-declaration

| opaque-enum-declaration

referenced by: declaration-statement name-declaration nodeclspec-function-declaration:

nodeclspec-function-declaration

::= attribute-specifier-seq? declarator ';'

referenced by: name-declaration alias-declaration:

alias-declaration

::= 'using' identifier attribute-specifier-seq? '=' defining-type-id ';'

referenced by: block-declaration init-statement member-declaration simple-declaration:

simple-declaration

::= ( decl-specifier-seq init-declarator-list? | attribute-specifier-seq decl-specifier-seq init-declarator-list | attribute-specifier-seq? decl-specifier-seq ref-qualifier? '[' identifier-list ']' initializer ) ';'

referenced by: block-declaration init-statement static_assert-message:

static_assert-message

::= unevaluated-string

| constant-expression

referenced by: static_assert-declaration static_assert-declaration:

static_assert-declaration

::= 'static_assert' '(' constant-expression ( ',' static_assert-message )? ')' ';'

referenced by: block-declaration member-declaration attribute-declaration:

attribute-declaration

::= attribute-specifier-seq ';'

referenced by: name-declaration decl-specifier:

decl-specifier

::= storage-class-specifier

| defining-type-specifier

| function-specifier

| 'friend'

| 'typedef'

| 'constexpr'

| 'consteval'

| 'constinit'

| 'inline'

referenced by: decl-specifier-seq decl-specifier-seq:

decl-specifier-seq

::= decl-specifier+ attribute-specifier-seq?

referenced by: condition for-range-declaration function-definition member-declaration parameter-declaration simple-declaration storage-class-specifier:

storage-class-specifier

::= 'static'

| 'thread_local'

| 'extern'

| 'mutable'

referenced by: decl-specifier function-specifier:

function-specifier

::= 'virtual'

| explicit-specifier

referenced by: decl-specifier explicit-specifier:

explicit-specifier

::= 'explicit' ( '(' constant-expression ')' )?

referenced by: deduction-guide function-specifier typedef-name:

typedef-name

::= identifier

| simple-template-id

referenced by: pack-index-specifier type-name type-specifier:

type-specifier

::= simple-type-specifier

| elaborated-type-specifier

| typename-specifier

| cv-qualifier

referenced by: defining-type-specifier type-specifier-seq type-specifier-seq:

type-specifier-seq

::= type-specifier+ attribute-specifier-seq?

referenced by: conversion-type-id enum-base exception-declaration new-type-id type-id defining-type-specifier:

defining-type-specifier

::= type-specifier

| class-specifier

| enum-specifier

referenced by: decl-specifier defining-type-id simple-type-specifier:

simple-type-specifier

::= nested-name-specifier? ( type-name | template-name )

| nested-name-specifier 'template' simple-template-id

| computed-type-specifier

| placeholder-type-specifier

| 'char'

| 'char8_t'

| 'char16_t'

| 'char32_t'

| 'wchar_t'

| 'bool'

| 'short'

| 'int'

| 'long'

| 'signed'

| 'unsigned'

| 'float'

| 'double'

| 'void'

referenced by: cast-expression type-specifier type-name:

type-name

::= class-name

| enum-name

| typedef-name

referenced by: class-or-decltype nested-name-specifier simple-type-specifier type-requirement unqualified-id computed-type-specifier:

computed-type-specifier

::= decltype-specifier

| pack-index-specifier

referenced by: nested-name-specifier simple-type-specifier unqualified-id pack-index-specifier:

pack-index-specifier

::= typedef-name '...' '[' constant-expression ']'

referenced by: computed-type-specifier elaborated-type-specifier:

elaborated-type-specifier

::= class-key ( attribute-specifier-seq? nested-name-specifier? identifier | ( nested-name-specifier 'template'? )? simple-template-id )

| 'enum' nested-name-specifier? identifier

referenced by: type-specifier decltype-specifier:

decltype-specifier

::= 'decltype' '(' expression ')'

referenced by: class-or-decltype computed-type-specifier placeholder-type-specifier:

placeholder-type-specifier

::= type-constraint? ( 'auto' | 'decltype' '(' 'auto' ')' )

referenced by: simple-type-specifier init-declarator-list:

init-declarator-list

::= init-declarator ( ',' init-declarator )*

referenced by: simple-declaration init-declarator:

init-declarator

::= declarator ( initializer | requires-clause )?

referenced by: init-declarator-list declarator:

declarator

::= ptr-declarator

| noptr-declarator parameters-and-qualifiers trailing-return-type

referenced by: condition exception-declaration for-range-declaration function-definition init-declarator member-declarator nodeclspec-function-declaration parameter-declaration ptr-declarator:

ptr-declarator

::= ptr-operator* noptr-declarator

referenced by: declarator noptr-declarator noptr-declarator:

noptr-declarator

::= ( declarator-id attribute-specifier-seq? | '(' ptr-declarator ')' ) ( parameters-and-qualifiers | '[' constant-expression? ']' attribute-specifier-seq? )*

referenced by: declarator ptr-declarator parameters-and-qualifiers:

parameters-and-qualifiers

::= '(' parameter-declaration-clause ')' cv-qualifier-seq? ref-qualifier? noexcept-specifier? attribute-specifier-seq?

referenced by: abstract-declarator declarator noptr-abstract-declarator noptr-declarator trailing-return-type:

trailing-return-type

::= '->' type-id

referenced by: abstract-declarator declarator lambda-declarator ptr-operator:

ptr-operator

::= nested-name-specifier? '*' attribute-specifier-seq? cv-qualifier-seq?

| ( '&' | '&&' ) attribute-specifier-seq?

referenced by: abstract-declarator conversion-type-id new-type-id ptr-abstract-declarator ptr-declarator cv-qualifier-seq:

cv-qualifier-seq

::= cv-qualifier+

referenced by: parameters-and-qualifiers ptr-operator cv-qualifier:

cv-qualifier

::= 'const'

| 'volatile'

referenced by: cv-qualifier-seq type-specifier ref-qualifier:

ref-qualifier

::= '&'

| '&&'

referenced by: for-range-declaration parameters-and-qualifiers simple-declaration declarator-id:

declarator-id

::= '...'? id-expression

referenced by: noptr-declarator type-id:

type-id ::= type-specifier-seq abstract-declarator?

referenced by: alignment-specifier cast-expression new-expression template-argument trailing-return-type type-parameter defining-type-id:

defining-type-id

::= defining-type-specifier+ attribute-specifier-seq? abstract-declarator?

referenced by: alias-declaration abstract-declarator:

abstract-declarator

::= ptr-abstract-declarator

| noptr-abstract-declarator? parameters-and-qualifiers trailing-return-type

| ptr-operator* '...' parameters-and-qualifiers*

referenced by: defining-type-id exception-declaration parameter-declaration type-id ptr-abstract-declarator:

ptr-abstract-declarator

::= ptr-operator* ( noptr-abstract-declarator | ptr-operator )

referenced by: abstract-declarator noptr-abstract-declarator noptr-abstract-declarator:

noptr-abstract-declarator

::= ( parameters-and-qualifiers | '[' constant-expression? ']' attribute-specifier-seq? | '(' ptr-abstract-declarator ')' ) ( parameters-and-qualifiers | '[' constant-expression? ']' attribute-specifier-seq? )*

referenced by: abstract-declarator ptr-abstract-declarator parameter-declaration-clause:

parameter-declaration-clause

::= parameter-declaration-list? '...'?

| parameter-declaration-list ',' '...'

referenced by: deduction-guide lambda-declarator parameters-and-qualifiers requirement-parameter-list parameter-declaration-list:

parameter-declaration-list

::= parameter-declaration ( ',' parameter-declaration )*

referenced by: parameter-declaration-clause parameter-declaration:

parameter-declaration

::= attribute-specifier-seq? ( 'this'? decl-specifier-seq ( declarator | abstract-declarator )? | decl-specifier-seq ( declarator | abstract-declarator )? '=' initializer-clause )

referenced by: parameter-declaration-list template-parameter initializer:

initializer

::= brace-or-equal-initializer

| '(' expression-list ')'

referenced by: init-capture init-declarator simple-declaration brace-or-equal-initializer:

brace-or-equal-initializer

::= '=' initializer-clause

| braced-init-list

referenced by: condition designated-initializer-clause initializer member-declarator initializer-clause:

initializer-clause

::= assignment-expression

| braced-init-list

referenced by: assignment-expression brace-or-equal-initializer initializer-list parameter-declaration braced-init-list:

braced-init-list

::= '{' ( ( initializer-list | designated-initializer-clause ( ',' designated-initializer-clause )* ) ','? )? '}'

referenced by: brace-or-equal-initializer cast-expression expr-or-braced-init-list initializer-clause mem-initializer new-initializer template-argument yield-expression initializer-list:

initializer-list

::= initializer-clause '...'? ( ',' initializer-clause '...'? )*

referenced by: braced-init-list expression-list designated-initializer-clause:

designated-initializer-clause

::= designator brace-or-equal-initializer

referenced by: braced-init-list designator:

designator

::= '.' identifier

referenced by: designated-initializer-clause expr-or-braced-init-list:

expr-or-braced-init-list

::= expression

| braced-init-list

referenced by: coroutine-return-statement for-range-initializer jump-statement function-definition:

function-definition

::= attribute-specifier-seq? decl-specifier-seq? declarator ( virt-specifier-seq | requires-clause )? function-body

referenced by: member-declaration name-declaration function-body:

function-body

::= ctor-initializer? compound-statement

| function-try-block

| '=' ( 'default' | 'delete' ) ';'

referenced by: function-definition enum-name:

enum-name

::= identifier

referenced by: type-name enum-specifier:

enum-specifier

::= enum-head '{' ( enumerator-definition ( ',' enumerator-definition )* ','? )? '}'

referenced by: defining-type-specifier enum-head:

enum-head

::= enum-key attribute-specifier-seq? enum-head-name? enum-base?

referenced by: enum-specifier enum-head-name:

enum-head-name

::= nested-name-specifier? identifier

referenced by: enum-head opaque-enum-declaration opaque-enum-declaration:

opaque-enum-declaration

::= enum-key attribute-specifier-seq? enum-head-name enum-base? ';'

referenced by: block-declaration member-declaration enum-key:

enum-key ::= 'enum' ( 'class' | 'struct' )?

referenced by: enum-head opaque-enum-declaration enum-base:

enum-base

::= ':' type-specifier-seq

referenced by: enum-head opaque-enum-declaration enumerator-definition:

enumerator-definition

::= enumerator ( '=' constant-expression )?

referenced by: enum-specifier enumerator:

enumerator

::= identifier attribute-specifier-seq?

referenced by: enumerator-definition using-enum-declaration:

using-enum-declaration

::= 'using' 'enum' using-enum-declarator ';'

referenced by: block-declaration member-declaration using-enum-declarator:

using-enum-declarator

::= nested-name-specifier? ( identifier | simple-template-id )

referenced by: using-enum-declaration namespace-name:

namespace-name

::= identifier

| namespace-alias

referenced by: nested-name-specifier qualified-namespace-specifier using-directive namespace-definition:

namespace-definition

::= named-namespace-definition

| unnamed-namespace-definition

| nested-namespace-definition

referenced by: name-declaration named-namespace-definition:

named-namespace-definition

::= 'inline'? 'namespace' attribute-specifier-seq? identifier '{' namespace-body '}'

referenced by: namespace-definition unnamed-namespace-definition:

unnamed-namespace-definition

::= 'inline'? 'namespace' attribute-specifier-seq? '{' namespace-body '}'

referenced by: namespace-definition nested-namespace-definition:

nested-namespace-definition

::= 'namespace' identifier ( '::' 'inline'? identifier )+ '{' namespace-body '}'

referenced by: namespace-definition namespace-body:

namespace-body

::= declaration-seq?

referenced by: named-namespace-definition nested-namespace-definition unnamed-namespace-definition namespace-alias:

namespace-alias

::= identifier

referenced by: namespace-name namespace-alias-definition:

namespace-alias-definition

::= 'namespace' identifier '=' qualified-namespace-specifier ';'

referenced by: block-declaration qualified-namespace-specifier:

qualified-namespace-specifier

::= nested-name-specifier? namespace-name

referenced by: namespace-alias-definition using-directive:

using-directive

::= attribute-specifier-seq? 'using' 'namespace' nested-name-specifier? namespace-name ';'

referenced by: block-declaration using-declaration:

using-declaration

::= 'using' using-declarator '...'? ( ',' using-declarator '...'? )* ';'

referenced by: block-declaration member-declaration using-declarator:

using-declarator

::= 'typename'? nested-name-specifier unqualified-id

referenced by: using-declaration asm-declaration:

asm-declaration

::= attribute-specifier-seq? 'asm' '(' balanced-token-seq ')' ';'

referenced by: block-declaration linkage-specification:

linkage-specification

::= 'extern' unevaluated-string ( '{' declaration-seq? '}' | name-declaration )

referenced by: name-declaration attribute-specifier-seq:

attribute-specifier-seq

::= attribute-specifier+

referenced by: alias-declaration asm-declaration attribute-declaration base-specifier class-head concept-definition condition decl-specifier-seq defining-type-id elaborated-type-specifier enum-head enumerator exception-declaration for-range-declaration function-definition label lambda-declarator lambda-expression member-declaration member-declarator module-declaration module-import-declaration named-namespace-definition new-type-id nodeclspec-function-declaration noptr-abstract-declarator noptr-declarator opaque-enum-declaration parameter-declaration parameters-and-qualifiers ptr-operator simple-declaration statement type-specifier-seq unnamed-namespace-definition using-directive attribute-specifier:

attribute-specifier

::= '[' '[' attribute-using-prefix? ( attribute '...'? )? ( ',' ( attribute '...'? )? )* ']' ']'

| alignment-specifier

referenced by: attribute-specifier-seq alignment-specifier:

alignment-specifier

::= 'alignas' '(' ( type-id | constant-expression ) '...'? ')'

referenced by: attribute-specifier attribute-using-prefix:

attribute-using-prefix

::= 'using' attribute-namespace ':'

referenced by: attribute-specifier attribute:

attribute

::= attribute-token attribute-argument-clause?

referenced by: attribute-specifier attribute-token:

attribute-token

::= identifier

| attribute-scoped-token

referenced by: attribute attribute-scoped-token:

attribute-scoped-token

::= attribute-namespace '::' identifier

referenced by: attribute-token attribute-namespace:

attribute-namespace

::= identifier

referenced by: attribute-scoped-token attribute-using-prefix attribute-argument-clause:

attribute-argument-clause

::= '(' balanced-token-seq? ')'

referenced by: attribute balanced-token-seq:

balanced-token-seq

::= balanced-token+

referenced by: asm-declaration attribute-argument-clause balanced-token balanced-token:

balanced-token

::= '(' balanced-token-seq? ')'

| '[' balanced-token-seq? ']'

| '{' balanced-token-seq? '}'

| '{any token other than a parenthesis, a bracket, or a brace}'

referenced by: balanced-token-seq module-declaration:

module-declaration

::= 'export'? 'module' module-name module-partition? attribute-specifier-seq? ';'

referenced by: translation-unit module-name:

module-name

::= module-name-qualifier? identifier

referenced by: module-declaration module-import-declaration module-partition:

module-partition

::= ':' module-name-qualifier? identifier

referenced by: module-declaration module-import-declaration module-name-qualifier:

module-name-qualifier

::= ( identifier '.' )+

referenced by: module-name module-partition export-declaration:

export-declaration

::= 'export' ( name-declaration | '{' declaration-seq? '}' | module-import-declaration )

referenced by: special-declaration module-import-declaration:

module-import-declaration

::= 'import' ( module-name | module-partition | header-name ) attribute-specifier-seq? ';'

referenced by: export-declaration name-declaration global-module-fragment:

global-module-fragment

::= 'module' ';' declaration-seq?

referenced by: translation-unit private-module-fragment:

private-module-fragment

::= 'module' ':' 'private' ';' declaration-seq?

referenced by: translation-unit class-name:

class-name

::= identifier

| simple-template-id

referenced by: class-head-name type-name class-specifier:

class-specifier

::= class-head '{' ( member-declaration | access-specifier ':' )* '}'

referenced by: defining-type-specifier class-head:

class-head

::= class-key attribute-specifier-seq? ( class-head-name 'final'? )? base-clause?

referenced by: class-specifier class-head-name:

class-head-name

::= nested-name-specifier? class-name

referenced by: class-head class-key:

class-key

::= 'class'

| 'struct'

| 'union'

referenced by: class-head elaborated-type-specifier member-declaration:

member-declaration

::= ( attribute-specifier-seq? decl-specifier-seq? ( member-declarator ( ',' member-declarator )* )? )? ';'

| function-definition

| using-declaration

| using-enum-declaration

| static_assert-declaration

| template-declaration

| explicit-specialization

| deduction-guide

| alias-declaration

| opaque-enum-declaration

referenced by: class-specifier member-declarator:

member-declarator

::= declarator ( virt-specifier-seq? pure-specifier? | requires-clause | brace-or-equal-initializer )?

| identifier? attribute-specifier-seq? ':' constant-expression brace-or-equal-initializer?

referenced by: member-declaration virt-specifier-seq:

virt-specifier-seq

::= virt-specifier+

referenced by: function-definition member-declarator virt-specifier:

virt-specifier

::= 'override'

| 'final'

referenced by: virt-specifier-seq pure-specifier:

pure-specifier

::= '=' '0'

referenced by: member-declarator conversion-function-id:

conversion-function-id

::= 'operator' conversion-type-id

referenced by: unqualified-id conversion-type-id:

conversion-type-id

::= type-specifier-seq ptr-operator*

referenced by: conversion-function-id base-clause:

base-clause

::= ':' base-specifier '...'? ( ',' base-specifier '...'? )*

referenced by: class-head base-specifier:

base-specifier

::= attribute-specifier-seq? ( 'virtual' access-specifier? | access-specifier 'virtual'? )? class-or-decltype

referenced by: base-clause class-or-decltype:

class-or-decltype

::= nested-name-specifier? type-name

| nested-name-specifier 'template' simple-template-id

| decltype-specifier

referenced by: base-specifier mem-initializer-id access-specifier:

access-specifier

::= 'private'

| 'protected'

| 'public'

referenced by: base-specifier class-specifier ctor-initializer:

ctor-initializer

::= ':' mem-initializer '...'? ( ',' mem-initializer '...'? )*

referenced by: function-body function-try-block mem-initializer:

mem-initializer

::= mem-initializer-id ( '(' expression-list? ')' | braced-init-list )

referenced by: ctor-initializer mem-initializer-id:

mem-initializer-id

::= class-or-decltype

| identifier

referenced by: mem-initializer operator-function-id:

operator-function-id

::= 'operator' operator

referenced by: template-id unqualified-id operator:

operator ::= 'new'

| 'delete'

| 'new[]'

| 'delete[]'

| 'co_await'

| '()'

| '[]'

| '->'

| '->*'

| '~'

| '!'

| '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '='

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '=='

| '!='

| '<'

| '>'

| '<='

| '>='

| '<=>'

| '&&'

| '||'

| '<<'

| '>>'

| '<<='

| '>>='

| '++'

| '--'

| ','

referenced by: operator-function-id literal-operator-id:

literal-operator-id

::= 'operator' ( unevaluated-string identifier | user-defined-string-literal )

referenced by: template-id unqualified-id template-declaration:

template-declaration

::= template-head ( declaration | concept-definition )

referenced by: member-declaration name-declaration template-head:

template-head

::= 'template' '<' template-parameter-list '>' requires-clause?

referenced by: template-declaration type-parameter template-parameter-list:

template-parameter-list

::= template-parameter ( ',' template-parameter )*

referenced by: lambda-expression template-head requires-clause:

requires-clause

::= 'requires' constraint-logical-and-expression ( '||' constraint-logical-and-expression )*

referenced by: function-definition init-declarator lambda-declarator lambda-expression member-declarator template-head constraint-logical-and-expression:

constraint-logical-and-expression

::= primary-expression ( '&&' primary-expression )*

referenced by: requires-clause template-parameter:

template-parameter

::= type-parameter

| parameter-declaration

referenced by: template-parameter-list type-parameter:

type-parameter

::= ( type-parameter-key | type-constraint ) ( '...'? identifier? | identifier? '=' type-id )

| template-head type-parameter-key ( '...'? identifier? | identifier? '=' id-expression )

referenced by: template-parameter type-parameter-key:

type-parameter-key

::= 'class'

| 'typename'

referenced by: type-parameter type-constraint:

type-constraint

::= nested-name-specifier? concept-name ( '<' template-argument-list? '>' )?

referenced by: placeholder-type-specifier return-type-requirement type-parameter simple-template-id:

simple-template-id

::= template-name '<' template-argument-list? '>'

referenced by: class-name class-or-decltype deduction-guide elaborated-type-specifier nested-name-specifier simple-type-specifier template-id typedef-name typename-specifier using-enum-declarator template-id:

template-id

::= simple-template-id

| ( operator-function-id | literal-operator-id ) '<' template-argument-list? '>'

referenced by: unqualified-id template-name:

template-name

::= identifier

referenced by: deduction-guide simple-template-id simple-type-specifier template-argument-list:

template-argument-list

::= template-argument '...'? ( ',' template-argument '...'? )*

referenced by: simple-template-id template-id type-constraint template-argument:

template-argument

::= constant-expression

| type-id

| id-expression

| braced-init-list

referenced by: template-argument-list constraint-expression:

constraint-expression

::= logical-or-expression

referenced by: concept-definition nested-requirement deduction-guide:

deduction-guide

::= explicit-specifier? template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'

referenced by: member-declaration name-declaration concept-definition:

concept-definition

::= 'concept' concept-name attribute-specifier-seq? '=' constraint-expression ';'

referenced by: template-declaration concept-name:

concept-name

::= identifier

referenced by: concept-definition type-constraint typename-specifier:

typename-specifier

::= 'typename' nested-name-specifier ( identifier | 'template'? simple-template-id )

referenced by: cast-expression type-specifier explicit-instantiation:

explicit-instantiation

::= 'extern'? 'template' declaration

referenced by: special-declaration explicit-specialization:

explicit-specialization

::= 'template' '<' '>' declaration

referenced by: member-declaration special-declaration try-block:

try-block

::= 'try' compound-statement handler-seq

referenced by: statement function-try-block:

function-try-block

::= 'try' ctor-initializer? compound-statement handler-seq

referenced by: function-body handler-seq:

handler-seq

::= handler+

referenced by: function-try-block try-block handler:

handler ::= 'catch' '(' exception-declaration ')' compound-statement

referenced by: handler-seq exception-declaration:

exception-declaration

::= attribute-specifier-seq? type-specifier-seq ( declarator | abstract-declarator )?

| '...'

referenced by: handler noexcept-specifier:

noexcept-specifier

::= 'noexcept' ( '(' constant-expression ')' )?

referenced by: lambda-declarator parameters-and-qualifiers preprocessing-file:

preprocessing-file

::= ( group | module-file )?

referenced by: cplusplus module-file:

module-file

::= pp-global-module-fragment? pp-module group? pp-private-module-fragment?

referenced by: preprocessing-file pp-global-module-fragment:

pp-global-module-fragment

::= 'module' ';' '{the new-line character}' group?

referenced by: module-file pp-private-module-fragment:

pp-private-module-fragment

::= 'module' ':' 'private' ';' '{the new-line character}' group?

referenced by: module-file group:

group ::= group-part+

referenced by: elif-group else-group if-group module-file pp-global-module-fragment pp-private-module-fragment preprocessing-file group-part:

group-part

::= control-line

| if-section

| text-line

| '#' conditionally-supported-directive

referenced by: group control-line:

control-line

::= '#' ( ( 'include' | 'line' ) pp-tokens | 'undef' identifier | ( 'error' | 'warning' | 'pragma' ) pp-tokens? | 'define' identifier ( '{a "(" character not immediately preceded by whitespace}' ( identifier-list | ( identifier-list ',' )? '...' )? ')' )? replacement-list )? '{the new-line character}'

| pp-import

referenced by: group-part if-section:

if-section

::= if-group elif-group* else-group? endif-line

referenced by: group-part if-group:

if-group ::= '#' ( 'if' constant-expression | ( 'ifdef' | 'ifndef' ) identifier ) '{the new-line character}' group?

referenced by: if-section elif-group:

elif-group

::= '#' ( 'elif' constant-expression | ( 'elifdef' | 'elifndef' ) identifier ) '{the new-line character}' group?

referenced by: if-section else-group:

else-group

::= '#' 'else' '{the new-line character}' group?

referenced by: if-section endif-line:

endif-line

::= '#' 'endif' '{the new-line character}'

referenced by: if-section text-line:

text-line

::= pp-tokens? '{the new-line character}'

referenced by: group-part conditionally-supported-directive:

conditionally-supported-directive

::= pp-tokens '{the new-line character}'

referenced by: group-part identifier-list:

identifier-list

::= identifier ( ',' identifier )*

referenced by: control-line for-range-declaration simple-declaration replacement-list:

replacement-list

::= pp-tokens?

referenced by: control-line pp-tokens:

pp-tokens

::= preprocessing-token+

referenced by: conditionally-supported-directive control-line has-attribute-expression pp-import pp-module replacement-list text-line va-opt-replacement defined-macro-expression:

defined-macro-expression

::= 'defined' ( identifier | '(' identifier ')' )