grammar

nondigit

We say that a string s is a nondigit when it is one of the following characters:

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

_

digit

We say that a string s is a digit when it is one of the following characters:

0

1

2

3

4

5

6

7

8

9

integer-literal

We say that a string s is an integer-literal when it is any of the following:

• binary-literal integer-suffixopt
• octal-literal integer-suffixopt
• decimal-literal integer-suffixopt
• hexadecimal-literal integer-suffix

primary-expression

We say that a string s is a primary-expression when it is any of the following:

• literal
• this
• ( expression )
• id-expression
• lambda-expression
• fold-expression
• requires-expression
• splice-expression

postfix-expression

We say that a string s is a postfix-expression when it is any of the following:

• primary-expression
• postfix-expression [ expression-listopt ]
• postfix-expression ( expression-listopt )
• simple-type-specifier ( expression-listopt )
• typename-specifier ( expression-listopt )
• simple-type-specifier braced-init-list
• typename-specifier braced-init-list
• postfix-expression . templateopt id-expression
• postfix-expression . splice-expression
• postfix-expression -> templateopt id-expression
• postfix-expression -> splice-expression
• postfix-expression ++
• postfix-expression --
• dynamic_cast < type-id > ( expression )
• static_cast < type-id > ( expression )
• reinterpret_cast < type-id > ( expression )
• const_cast < type-id > ( expression )
• typeid ( expression )
• typeid ( type-id )

unary-expression

We say that a string s is a unary-expression when it is any of the following:

• postfix-expression
• unary-operator cast-expression
• ++ cast-expression
• -- cast-expression
• await-expression
• sizeof unary-expression
• sizeof ( type-id )
• sizeof ... ( identifier )
• alignof ( type-id )
• noexcept-expression
• new-expression
• delete-expression
• reflect-expression

cast-expression

We say that a string s is a cast-expression when it is any of the following:

• unary-expression
• ( type-id ) cast-expression

pm-expression

We say that a string s is a pm-expression when it is any of the following:

• cast-expression
• pm-expression .* cast-expression
• pm-expression ->* cast-expression

multiplicative-expression

We say that a string s is a multiplicative-expression when it is any of the following:

• pm-expression
• multiplicative-expression * pm-expression
• multiplicative-expression / pm-expression
• multiplicative-expression % pm-expression

additive-expression

We say that a string s is an additive-expression when it is any of the following:

• multiplicative-expression
• additive-expression + multiplicative-expression
• additive-expression - multiplicative-expression

shift-expression

We say that a string s is a shift-expression when it is any of the following:

• additive-expression
• shift-expression << additive-expression
• shift-expression >> additive-expression

compare-expression

We say that a string s is a compare-expression when it is any of the following:

• shift-expression
• compare-expression <=> shift-expression

relational-expression

We say that a string s is a relational-expression when it is any of the following:

• compare-expression
• relational-expression < compare-expression
• relational-expression > compare-expression
• relational-expression <= compare-expression
• relational-expression >= compare-expression

equality-expression

We say that a string s is an equality-expression when it is any of the following:

• relational-expression
• equality-expression == relational-expression
• equality-expression != relational-expression

and-expression

We say that a string s is an and-expression when it is any of the following:

• equality-expression
• and-expression & equality-expression

exclusive-or-expression

We say that a string s is an exclusive-or-expression when it is any of the following:

• and-expression
• exclusive-or-expression ^ and-expression

inclusive-or-expression

We say that a string s is an inclusive-or-expression when it is any of the following:

• exclusive-or-expression
• inclusive-or-expression | exclusive-or-expression

logical-and-expression

We say that a string s is a logical-and-expression when it is any of the following:

• inclusive-or-expression
• logical-and-expression && inclusive-or-expression

logical-or-expression

We say that a string s is a logical-or-expression when it is any of the following:

• logical-and-expression
• logical-or-expression || logical-and-expression

conditional-expression

We say that a string s is a conditional-expression when it is any of the following:

• logical-or-expression
• logical-or-expression ? expression : assignment-expression

assignment-expression

We say that a string s is an assignment-expression when it is any of the following:

• conditional-expression
• yield-expression
• throw-expression
• logical-or-expression assignment-operator initializer-clause

expression

We say that a string s is an expression when it is any of the following:

• assignment-expression
• expression, assignment-expression

identifier-start

We say that a string s is an identifier-start when it is any of the following:

• nondigit

identifier-continue

We say that a string s is an identifier-continue when it is any of the following:

• digit
• nondigit
• an element of the translation character set with the Unicode property XID_Continue

operator

We say that a string s is an operator when it is any of the following:

new	delete	new[]	delete[]
co_await	( )	[ ]	->
->*	~	!	+
-	*	/	%
^	&	|	=
+=	-=	*=	/=
%=	^=	&=	|=
==	!=	<	>
<=	>=	<=>	&&
||	<<	>>	<<=
>>=	++	--	,

operator-function-id

We say that a string s is an operator-function-id when it is any of the following:

• operator operator

template-name

We say that a string s is a template-name when it is any of the following:

• identifier

template-argument-name

We say that a string s is a template-argument-name when it is any of the following:

• nested-name-specifieropt identifier
• nested-name-specifier template identifier

nested-name-specifier

We say that a string s is a nested-name-specifier when it is any of the following:

• ::
• type-name ::
• namespace-name ::
• computed-type-specifier ::
• splice-scope-specifier ::
• nested-name-specifier identifier ::
• nested-name-specifier templateopt simple-template-id ::

namespace-name

We say that a string s is a namespace-name when it is any of the following:

• identifier
• namespace-alias

computed-type-specifier

We say that a string s is a computed-type-specifier when it is any of the following:

• decltype-specifier
• pack-index-specifier
• splice-type-specifier

nested-name-specifier

We say that a string s is a nested-name-specifier when it is any of the following:

• ::
• type-name ::
• namespace-name ::
• computed-type-specifier ::
• splice-scope-specifier ::
• nested-name-specifier identifier ::
• nested-name-specifier templateopt simple-template-id ::

template-argument

We say that a string s is a template-argument when it is any of the following:

• template-argument-name
• constant-expression
• type-id
• braced-init-list

template-argument-list

We say that a string s is a template-argument-list when it is any of the following:

• template-argument ...opt
• template-argument-list, template-argument ...

simple-template-id

We say that a string s is a simple-template-id when it consists of the following:

• template-name < template-argument-listopt >

type-name

We say that a string s is a type-name when it is any of the following:

• class-name
• enum-name
• typedef-name

simple-type-specifier

We say that a string s is a simple-type-specifier when it is any of the following:

• nested-name-specifieropt type-name
• nested-name-specifier template simple-template-id
• computed-type-specifier
• placeholder-type-specifier
• nested-name-specifieropt template-name
• char
• char8_t
• char16_t
• char32_t
• wchar_t
• bool
• short
• int
• long
• signed
• unsigned
• float
• double
• void

identifier

We say that a string s is an identifier when it is any of the following:

• identifier-start
• identifier identifier-continue

Examples

• myVar
• my_var can use underscore
• _hidden can start with underscore
• foo123 can contain digits after the first character
• Ωmega can include Unicode letters

Non-examples

• 123abc cannot start with a digit
• var-name hyphens are not allowed
• !important special characters like ! are not allowed
• (space) whitespace is not allowed

unqualified-id

We say that a string s is an unqualified-id when it is any of the following:

• identifier
• operator-function-id
• conversion-function-id
• literal-operator-id
• ~ type-name
• ~ computed-type-specifier
• template-id

id-expression

We say that a string s is an id-expression when it is any of the following:

• unqualified-id
• qualified-id
• pack-index-expression