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

identifier-nondigit

::= nondigit

| universal-character-name

| '{other implementation-defined characters}'

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 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

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

referenced by: literal decimal-literal:

decimal-literal

::= nonzero-digit digit*

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

octal-literal

::= '0' octal-digit*

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

hexadecimal-literal

::= ( '0x' | '0X' ) hexadecimal-digit+

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

nonzero-digit

::= '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

| '8'

| '9'

referenced by: decimal-literal octal-digit:

octal-digit

::= '0'

| '1'

| '2'

| '3'

| '4'

| '5'

| '6'

| '7'

referenced by: octal-escape-sequence octal-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-literal 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

::= ( 'u' | 'U' | 'L' )? "'" c-char+ "'"

referenced by: literal preprocessing-token user-defined-character-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

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

referenced by: literal fractional-constant:

fractional-constant

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

| digit-sequence '.'

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

exponent-part

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

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

sign ::= '+'

| '-'

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

digit-sequence

::= digit+

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

floating-suffix

::= 'f'

| 'l'

| 'F'

| 'L'

referenced by: floating-literal string-literal:

string-literal

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

referenced by: asm-definition linkage-specification literal preprocessing-token static_assert-declaration user-defined-string-literal encoding-prefix:

encoding-prefix

::= 'u8'

| 'u'

| 'U'

| 'L'

referenced by: 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 ) ud-suffix

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

user-defined-floating-literal

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

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

user-defined-string-literal

::= string-literal ud-suffix

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

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

| '::' ( identifier | operator-function-id | literal-operator-id | template-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 declarator-id elaborated-type-specifier enum-head 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 ::= '&'? identifier

| 'this'

referenced by: capture-list lambda-declarator:

lambda-declarator

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

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

| '~' 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' | '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 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 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 expression-statement for-range-initializer iteration-statement jump-statement new-type-id noexcept-expression primary-expression constant-expression:

constant-expression

::= conditional-expression

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

::= labeled-statement

| declaration-statement

referenced by: compound-statement iteration-statement labeled-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: for-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' '(' condition ')' ( statement 'else' )? | 'switch' '(' condition ')' ) statement

referenced by: statement condition:

condition

::= expression

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

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

iteration-statement

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

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

referenced by: statement for-init-statement:

for-init-statement

::= expression-statement

| simple-declaration

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

for-range-declaration

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

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

for-range-initializer

::= expression

| braced-init-list

referenced by: iteration-statement jump-statement:

jump-statement

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

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

| function-definition

| template-declaration

| 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 alias-declaration:

alias-declaration

::= 'using' identifier attribute-specifier-seq? '=' 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 ) ';'

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

| type-specifier

| function-specifier

| 'friend'

| 'typedef'

| 'constexpr'

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

::= 'register'

| 'static'

| 'thread_local'

| 'extern'

| 'mutable'

referenced by: decl-specifier function-specifier:

function-specifier

::= 'inline'

| 'virtual'

| 'explicit'

referenced by: decl-specifier typedef-name:

typedef-name

::= identifier

referenced by: type-name type-specifier:

type-specifier

::= trailing-type-specifier

| class-specifier

| enum-specifier

referenced by: decl-specifier type-specifier-seq trailing-type-specifier:

trailing-type-specifier

::= simple-type-specifier

| elaborated-type-specifier

| typename-specifier

| cv-qualifier

referenced by: trailing-return-type type-specifier 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 simple-type-specifier:

simple-type-specifier

::= nested-name-specifier? type-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 trailing-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 ')'

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: trailing-type-specifier enum-name:

enum-name

::= identifier

referenced by: type-name enum-specifier:

enum-specifier

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

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

referenced by: enumerator-definition namespace-name:

namespace-name

::= original-namespace-name

| namespace-alias

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

original-namespace-name

::= identifier

referenced by: extension-namespace-definition namespace-name namespace-definition:

namespace-definition

::= named-namespace-definition

| unnamed-namespace-definition

referenced by: declaration named-namespace-definition:

named-namespace-definition

::= original-namespace-definition

| extension-namespace-definition

referenced by: namespace-definition original-namespace-definition:

original-namespace-definition

::= 'inline'? 'namespace' identifier '{' namespace-body '}'

referenced by: named-namespace-definition extension-namespace-definition:

extension-namespace-definition

::= 'inline'? 'namespace' original-namespace-name '{' namespace-body '}'

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

unnamed-namespace-definition

::= 'inline'? 'namespace' '{' namespace-body '}'

referenced by: namespace-definition namespace-body:

namespace-body

::= declaration-seq?

referenced by: extension-namespace-definition original-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 elaborated-type-specifier enum-head exception-declaration for-range-declaration function-definition labeled-statement lambda-declarator member-declaration member-declarator new-type-id noptr-abstract-declarator noptr-declarator opaque-enum-declaration parameter-declaration parameters-and-qualifiers ptr-operator simple-declaration statement trailing-return-type type-specifier-seq using-directive attribute-specifier:

attribute-specifier

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

| alignment-specifier

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

alignment-specifier

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

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-argument-clause:

attribute-argument-clause

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

referenced by: attribute balanced-token-seq:

balanced-token-seq

::= balanced-token? 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 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 ')' attribute-specifier-seq? cv-qualifier-seq? ref-qualifier? exception-specification?

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

trailing-return-type

::= '->' trailing-type-specifier+ attribute-specifier-seq? abstract-declarator?

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 trailing-type-specifier ref-qualifier:

ref-qualifier

::= '&'

| '&&'

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

declarator-id

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

| nested-name-specifier? class-name

referenced by: noptr-declarator type-id:

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

referenced by: alias-declaration alignment-specifier cast-expression dynamic-exception-specification new-expression template-argument type-parameter 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: exception-declaration parameter-declaration trailing-return-type 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: 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-declarator brace-or-equal-initializer:

brace-or-equal-initializer

::= '=' initializer-clause

| braced-init-list

referenced by: initializer member-declarator 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 for-range-initializer initializer-clause jump-statement mem-initializer new-initializer class-name:

class-name

::= identifier

| simple-template-id

referenced by: class-head-name class-or-decltype declarator-id type-name unqualified-id class-specifier:

class-specifier

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

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

| 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-list

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

mem-initializer-list

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

referenced by: ctor-initializer mem-initializer-list mem-initializer:

mem-initializer

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

referenced by: mem-initializer-list mem-initializer-id:

mem-initializer-id

::= class-or-decltype

| identifier

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

operator-function-id

::= 'operator' operator

referenced by: qualified-id template-id unqualified-id operator:

operator ::= 'new'

| 'delete'

| 'new[]'

| 'delete[]'

| '+'

| '-'

| '*'

| '/'

| '%'

| '^'

| '&'

| '|'

| '~'

| '!'

| '='

| '<'

| '>'

| '+='

| '-='

| '*='

| '/='

| '%='

| '^='

| '&='

| '|='

| '<<'

| '>>'

| '>>='

| '<<='

| '=='

| '!='

| '<='

| '>='

| '&&'

| '||'

| '++'

| '--'

| ','

| '->*'

| '->'

| '()'

| '[]'

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

literal-operator-id

::= 'operator' '""' identifier

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

::= ( 'class' | 'typename' ) ( '...'? identifier? | identifier? '=' type-id )

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

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

simple-template-id

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

referenced by: class-name 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: qualified-id unqualified-id template-name:

template-name

::= identifier

referenced by: simple-template-id 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 trailing-type-specifier explicit-instantiation:

explicit-instantiation

::= 'extern'? 'template' declaration

referenced by: declaration explicit-specialization:

explicit-specialization

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

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

throw-expression

::= 'throw' assignment-expression?

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

| '#' non-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 non-directive:

non-directive

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

referenced by: group-part identifier-list:

identifier-list

::= identifier ( ',' identifier )*

referenced by: control-line replacement-list:

replacement-list

::= pp-tokens?

referenced by: control-line pp-tokens:

pp-tokens

::= preprocessing-token+

referenced by: control-line non-directive replacement-list text-line ... generated by RR - Railroad Diagram Generator