referenced by: alias-declaration attribute-namespace attribute-scoped-token attribute-token cast-expression class-name control-line elaborated-type-specifier enum-head enum-name enumerator identifier-list if-group init-capture jump-statement labeled-statement literal-operator-id mem-initializer-id member-declarator named-namespace-definition namespace-alias namespace-alias-definition namespace-name nested-name-specifier nested-namespace-definition opaque-enum-declaration preprocessing-token simple-capture template-name type-parameter typedef-name typename-specifier ud-suffix unqualified-id identifier-nondigit:

identifier-nondigit

::= nondigit

| universal-character-name

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-nondigit preprocessing-token digit:

digit ::= '0'

| '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

| '8'

| '9'

referenced by: decimal-literal digit-sequence identifier preprocessing-token preprocessing-op-or-punc:

preprocessing-op-or-punc

::= '{'

| '}'

| '['

| ']'

| '#'

| '##'

| '('

| ')'

| '<:'

| ':>'

| '<%'

| '%>'

| '%:'

| '%:%:'

| ';'

| ':'

| '...'

| 'new'

| 'delete'

| '?'

| '::'

| '.'

| '.*'

| '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '~'

| '!'

| '='

| '<'

| '>'

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '<<'

| '>>'

| '>>='

| '<<='

| '=='

| '!='

| '<='

| '>='

| '&&'

| '||'

| '++'

| '--'

| ','

| '->*'

| '->'

| 'and'

| 'and_eq'

| 'bitand'

| 'bitor'

| 'compl'

| 'not'

| 'not_eq'

| 'or'

| 'or_eq'

| 'xor'

| 'xor_eq'

referenced by: preprocessing-token literal:

literal ::= integer-literal

| character-literal

| floating-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-literal hexadecimal-literal user-defined-floating-literal hexadecimal-digit-sequence:

hexadecimal-digit-sequence

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

referenced by: hexadecimal-floating-literal hexadecimal-fractional-constant hexadecimal-literal user-defined-floating-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: escape-sequence hex-quad hexadecimal-digit-sequence integer-suffix:

integer-suffix

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

| ( long-suffix | long-long-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 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 ::= '{any member of the source character set except the single-quote, backslash, or new-line character}'

| escape-sequence

| universal-character-name

referenced by: character-literal escape-sequence:

escape-sequence

::= simple-escape-sequence

| octal-escape-sequence

| '\x' hexadecimal-digit+

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

simple-escape-sequence

::= "\'"

| '\"'

| '\?'

| '\\'

| '\a'

| '\b'

| '\f'

| '\n'

| '\r'

| '\t'

| '\v'

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

octal-escape-sequence

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

referenced by: escape-sequence floating-literal:

floating-literal

::= decimal-floating-literal

| hexadecimal-floating-literal

referenced by: literal decimal-floating-literal:

decimal-floating-literal

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

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

hexadecimal-floating-literal

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

referenced by: floating-literal fractional-constant:

fractional-constant

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

| digit-sequence '.'

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

hexadecimal-fractional-constant

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

| hexadecimal-digit-sequence '.'

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

exponent-part

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

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

binary-exponent-part

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

referenced by: hexadecimal-floating-literal user-defined-floating-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-literal exponent-part fractional-constant user-defined-floating-literal floating-suffix:

floating-suffix

::= 'f'

| 'l'

| 'F'

| 'L'

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

string-literal

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

referenced by: asm-definition linkage-specification literal literal-operator-id preprocessing-token static_assert-declaration user-defined-string-literal s-char:

s-char ::= '{any member of the source character set except the double-quote, backslash, or new-line character}'

| escape-sequence

| universal-character-name

referenced by: string-literal raw-string:

raw-string

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

referenced by: string-literal r-char:

r-char ::= '{any member of the source character set, except}' '{a right parenthesis ")" followed by the initial \nonterminal{d-char-sequence}}' '{(which may be empty) followed by a double quote.}'

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 source character set except:}' '{space, the left parenthesis "(", the right parenthesis ")", the backslash "\",}' '{and the control characters representing horizontal tab,}' '{vertical tab, form feed, and newline.}'

referenced by: d-char-sequence boolean-literal:

boolean-literal

::= 'false'

| 'true'

referenced by: literal user-defined-literal:

user-defined-literal

::= user-defined-integer-literal

| user-defined-floating-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-literal:

user-defined-floating-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-literal user-defined-integer-literal user-defined-string-literal translation-unit:

translation-unit

::= declaration-seq?

referenced by: cplusplus primary-expression:

primary-expression

::= literal

| 'this'

| '(' expression ')'

| id-expression

| lambda-expression

| fold-expression

referenced by: cast-expression id-expression:

id-expression

::= unqualified-id

| qualified-id

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

unqualified-id

::= identifier

| operator-function-id

| conversion-function-id

| literal-operator-id

| '~' ( class-name | decltype-specifier )

| template-id

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

qualified-id

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

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

nested-name-specifier

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

referenced by: class-head-name class-or-decltype elaborated-type-specifier enum-head opaque-enum-declaration pseudo-destructor-name ptr-operator qualified-id qualified-namespace-specifier simple-type-specifier typename-specifier using-declaration using-directive lambda-expression:

lambda-expression

::= lambda-introducer lambda-declarator? compound-statement

referenced by: primary-expression lambda-introducer:

lambda-introducer

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

referenced by: lambda-expression 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 lambda-declarator:

lambda-declarator

::= '(' parameter-declaration-clause ')' decl-specifier-seq? exception-specification? attribute-specifier-seq? trailing-return-type?

referenced by: lambda-expression 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 expression-list:

expression-list

::= initializer-list

referenced by: cast-expression initializer mem-initializer new-initializer new-placement pseudo-destructor-name:

pseudo-destructor-name

::= ( nested-name-specifier? type-name | nested-name-specifier 'template' simple-template-id ) '::~' type-name

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

referenced by: cast-expression unary-operator:

unary-operator

::= '*'

| '&'

| '+'

| '-'

| '!'

| '~'

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 noexcept-expression:

noexcept-expression

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

referenced by: cast-expression cast-expression:

cast-expression

referenced by: 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: relational-expression relational-expression:

relational-expression

::= shift-expression ( ( '<' | '>' | '<=' | '>=' ) shift-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 conditional-expression:

conditional-expression

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

referenced by: assignment-expression constant-expression throw-expression:

throw-expression

::= 'throw' assignment-expression?

referenced by: assignment-expression assignment-expression:

assignment-expression

::= conditional-expression

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

| throw-expression

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

assignment-operator

::= '='

| '*='

| '/='

| '%='

| '+='

| '-='

| '>>='

| '<<='

| '&='

| '^='

| '|='

referenced by: assignment-expression expression:

expression

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

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

constant-expression

::= conditional-expression

referenced by: abstract-declarator alignment-specifier elif-group enumerator-definition if-group labeled-statement member-declarator new-type-id noexcept-specification noptr-abstract-declarator noptr-declarator static_assert-declaration template-argument statement:

statement

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

init-statement

::= ( expression-statement | simple-declaration )?

referenced by: iteration-statement selection-statement condition:

condition

::= ( expression | attribute-specifier-seq? decl-specifier-seq declarator ( '=' initializer-clause | braced-init-list ) )?

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

labeled-statement

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

referenced by: statement expression-statement:

expression-statement

::= expression? ';'

referenced by: init-statement statement compound-statement:

compound-statement

::= '{' statement* '}'

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

selection-statement

::= ( 'if' 'constexpr'? '(' init-statement? condition ')' ( statement 'else' )? | 'switch' '(' init-statement? condition ')' ) statement

referenced by: statement iteration-statement:

iteration-statement

::= ( 'while' '(' condition | 'for' '(' ( init-statement condition? ';' expression? | 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 ) ';'

referenced by: statement declaration-statement:

declaration-statement

::= block-declaration

referenced by: statement declaration-seq:

declaration-seq

::= declaration+

referenced by: linkage-specification namespace-body translation-unit declaration:

declaration

::= block-declaration

| nodeclspec-function-declaration

| function-definition

| template-declaration

| deduction-guide

| explicit-instantiation

| explicit-specialization

| linkage-specification

| namespace-definition

| ';'

| attribute-declaration

referenced by: declaration-seq explicit-instantiation explicit-specialization linkage-specification template-declaration block-declaration:

block-declaration

::= simple-declaration

| asm-definition

| namespace-alias-definition

| using-declaration

| using-directive

| static_assert-declaration

| alias-declaration

| opaque-enum-declaration

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

nodeclspec-function-declaration

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

referenced by: declaration alias-declaration:

alias-declaration

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

referenced by: block-declaration 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 ']' brace-or-equal-initializer ) ';'

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

static_assert-declaration

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

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

attribute-declaration

::= attribute-specifier-seq ';'

referenced by: declaration decl-specifier:

decl-specifier

::= storage-class-specifier

| defining-type-specifier

| function-specifier

| 'friend'

| 'typedef'

| 'constexpr'

| '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 lambda-declarator 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'

referenced by: decl-specifier typedef-name:

typedef-name

::= identifier

referenced by: 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

| 'char'

| 'char16_t'

| 'char32_t'

| 'wchar_t'

| 'bool'

| 'short'

| 'int'

| 'long'

| 'signed'

| 'unsigned'

| 'float'

| 'double'

| 'void'

| 'auto'

| decltype-specifier

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

type-name

::= class-name

| enum-name

| typedef-name

| simple-template-id

referenced by: nested-name-specifier pseudo-destructor-name simple-type-specifier decltype-specifier:

decltype-specifier

::= 'decltype' '(' ( expression | 'auto' ) ')'

referenced by: class-or-decltype nested-name-specifier pseudo-destructor-name simple-type-specifier unqualified-id 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 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? ( nested-name-specifier? identifier )? enum-base?

referenced by: enum-specifier opaque-enum-declaration:

opaque-enum-declaration

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

referenced by: block-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 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: 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 ( '::' 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-declaration:

using-declaration

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

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

using-directive

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

referenced by: block-declaration asm-definition:

asm-definition

::= 'asm' '(' string-literal ');'

referenced by: block-declaration linkage-specification:

linkage-specification

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

referenced by: declaration attribute-specifier-seq:

attribute-specifier-seq

::= attribute-specifier+

referenced by: abstract-declarator alias-declaration attribute-declaration base-specifier class-head condition decl-specifier-seq defining-type-id elaborated-type-specifier enum-head enumerator exception-declaration for-range-declaration function-definition labeled-statement lambda-declarator member-declaration member-declarator 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: 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 init-declarator-list:

init-declarator-list

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

referenced by: simple-declaration init-declarator:

init-declarator

::= declarator initializer?

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? exception-specification? 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 dynamic-exception-specification 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 | '[' constant-expression? ']' attribute-specifier-seq? )*

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 parameter-declaration-list:

parameter-declaration-list

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

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

parameter-declaration

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

referenced by: parameter-declaration-list template-parameter function-definition:

function-definition

::= attribute-specifier-seq? decl-specifier-seq? declarator virt-specifier-seq? function-body

referenced by: declaration member-declaration function-body:

function-body

::= ctor-initializer? compound-statement

| function-try-block

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

referenced by: function-definition initializer:

initializer

::= brace-or-equal-initializer

| '(' expression-list ')'

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

brace-or-equal-initializer

::= '=' initializer-clause

| braced-init-list

referenced by: initializer member-declarator simple-declaration initializer-clause:

initializer-clause

::= assignment-expression

| braced-init-list

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

initializer-list

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

referenced by: braced-init-list expression-list braced-init-list:

braced-init-list

::= '{' ( initializer-list ','? )? '}'

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

expr-or-braced-init-list

::= expression

| braced-init-list

referenced by: cast-expression for-range-initializer jump-statement class-name:

class-name

::= identifier

| simple-template-id

referenced by: class-head-name class-or-decltype type-name unqualified-id 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

| static_assert-declaration

| template-declaration

| deduction-guide

| alias-declaration

referenced by: class-specifier member-declarator:

member-declarator

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

| identifier? attribute-specifier-seq? ':' constant-expression

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 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'? )? base-type-specifier

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

class-or-decltype

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

| decltype-specifier

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

base-type-specifier

::= class-or-decltype

referenced by: base-specifier access-specifier:

access-specifier

::= 'private'

| 'protected'

| 'public'

referenced by: base-specifier class-specifier 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 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[]'

| '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '~'

| '!'

| '='

| '<'

| '>'

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '<<'

| '>>'

| '>>='

| '<<='

| '=='

| '!='

| '<='

| '>='

| '&&'

| '||'

| '++'

| '--'

| ','

| '->*'

| '->'

| '()'

| '[]'

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

literal-operator-id

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

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

template-declaration

::= 'template' '<' template-parameter-list '>' declaration

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

template-parameter-list

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

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

template-parameter

::= type-parameter

| parameter-declaration

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

type-parameter

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

| 'template' '<' template-parameter-list '>' type-parameter-key ( '...'? identifier? | identifier? '=' id-expression )

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

type-parameter-key

::= 'class'

| 'typename'

referenced by: type-parameter simple-template-id:

simple-template-id

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

referenced by: class-name deduction-guide elaborated-type-specifier nested-name-specifier pseudo-destructor-name simple-type-specifier template-id type-name typename-specifier 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 template-argument:

template-argument

::= constant-expression

| type-id

| id-expression

referenced by: template-argument-list 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: declaration explicit-specialization:

explicit-specialization

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

referenced by: declaration deduction-guide:

deduction-guide

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

referenced by: declaration member-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 exception-specification:

exception-specification

::= dynamic-exception-specification

| noexcept-specification

referenced by: lambda-declarator parameters-and-qualifiers dynamic-exception-specification:

dynamic-exception-specification

::= 'throw' '(' ( type-id '...'? ( ',' type-id '...'? )* )? ')'

referenced by: exception-specification noexcept-specification:

noexcept-specification

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

referenced by: exception-specification preprocessing-file:

preprocessing-file

::= group?

referenced by: cplusplus group:

group ::= group-part+

referenced by: elif-group else-group if-group preprocessing-file group-part:

group-part

::= if-section

| control-line

| text-line

| '#' conditionally-supported-directive

referenced by: group 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 '{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 control-line:

control-line

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

referenced by: group-part 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 replacement-list text-line ... generated by RR - Railroad Diagram Generator