class-name:

identifier

enum-name:

identifier

typedef-name:

identifier

identifier: one of

nondigit
identifier nondigit
identifier digit

nondigit: one of

_ 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: one of

0 1 2 3 4 5 6 7 8 9

---

expression:

assignment-expression
expression , assignment-expression

assignment-expression:

conditional-expression
unary-expression assignment-operator assignment-expression

assignment-operator: one of

= *= /= %= += –= >= <= &= ^= |=

conditional-expression:

logical-or-expression
logical-or-expression ? expression : conditional-expression

logical-or-expression:

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

logical-and-expression:

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

inclusive-or-expression:

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

exclusive-or-expression:

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

and-expression:

equality-expression
and-expression & equality-expression

equality-expression:

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

relational-expression:

shift-expression
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
relational-expression => shift-expression

shift-expression:

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

additive-expression:

multiplicative-expression
additive-expression + multiplicative-expression
additive-expression – multiplicative-expression

multiplicative-expression:

segment-expression
multiplicative-expression * segment-expression
multiplicative-expression / segment-expression
multiplicative-expression % segment-expression

segment-expression:

pm-expression
segment-expression :> pm-expression

pm-expression:

cast-expression
pm-expression .* cast-expression
pm-expression –>* cast-expression

cast-expression:

unary-expression
( type-name ) cast-expression

unary-expression:

postfix-expression
++ unary-expression
–– unary-expression
unary-operator cast-expression
sizeof unary-expression
sizeof ( type-name )
allocation-expression
deallocation-expression

unary-operator: one of

* & + – ! ~

allocation-expression:

::_opt new placement_opt new-type-name new-initializer_opt
::_opt new placement_opt ( type-name )   new-initializer_opt

placement:

( expression-list )

new-type-name:

type-specifier-list new-declarator_opt

new-declarator:

ms-modifier-list _opt   * cv-qualifier-list _opt new-declarator_opt
ms-modifier-list _opt   complete-class-name :: *cv-qualifier-list_opt
new-declarator_opt
new-declarator_opt [ expression ]

new-initializer:

( initializer-list )

deallocation-expression:

::_opt delete cast-expression
::_opt delete [ ] cast-expression

postfix-expression:

primary-expression
postfix-expression [ expression ]
postfix-expression   ( expression-list )
simple-type-name ( expression-list )
postfix-expression . name
postfix-expression –>   name
postfix-expression ++
postfix-expression ––
dynamic_cast < type-id > ( expression )
static_cast < type-id > ( expression )
const_cast < type-id > ( expression )
reinterpret_cast < type-id > ( expression )
typeid( expression )
typeid( type-id )

expression-list:

assignment-expression
expression-list , assignment-expression

primary-expression:

literal
this
:: identifier
:: operator-function-name
:: qualified-name ( expression )
name

name:

identifier
operator-function-name
conversion-function-name
   ~ class-name
qualified-name

qualified-name:

ms-modifier-list_opt qualified-class-name :: name

literal:

integer-constant
character-constant
floating-constant
string-literal

integer-constant:

decimal-constant integer-suffix_opt
octal-constant integer-suffix_opt
hexadecimal-constant integer-suffix_opt
'c-char-sequence'

decimal-constant:

nonzero-digit
decimal-constant digit

octal-constant:

0
octal-constant octal-digit

hexadecimal-constant:

0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit

nonzero-digit: one of

1 2 3 4 5 6 7 8 9

octal-digit: one of

0 1 2 3 4 5 6 7

hexadecimal-digit: one of

0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F

integer-suffix:

unsigned-suffix long-suffix_opt
long-suffix unsigned-suffix_opt

unsigned-suffix: one of

u U

long-suffix: one of

l L

character-constant:

'c-char-sequence'
L'c-char-sequence'

c-char-sequence:

c-char
c-char-sequence c-char

c-char:

any member of the source character set except the single quote ('),
   backslash (\), or newline character
escape-sequence

escape-sequence:

simple-escape-sequence
octal-escape-sequence
hexadecimal-escape-sequence

simple-escape-sequence: one of

\' \" \? \\
\a \b \f \n \r \t \v

octal-escape-sequence:

\ octal-digit
\ octal-digit octal-digit
\ octal-digit octal-digit octal-digit

hexadecimal-escape-sequence:

\xhexadecimal-digit
hexadecimal-escape-sequence hexadecimal-digit

floating-constant:

fractional-constant exponent-part_opt floating-suffix_opt
digit-sequence exponent-part floating-suffix_opt

fractional-constant:

digit-sequence_opt . digit-sequence
digit-sequence .

exponent-part:

e sign_opt digit-sequence
E sign_opt digit-sequence

sign: one of

+ –

digit-sequence:

digit
digit-sequence digit

floating-suffix: one of

f l F L

string literal:

''s-char-sequence _opt''
L ''s-char-sequence _opt''

s-char-sequence:

s-char
s-char-sequence s-char

s-char:

any member of the source character set except double quotation marks (_"), backslash (\), or newline character
escape-sequence

---

declaration:

decl-specifiers_opt declarator-list_opt ;
asm-declaration
function-definition
linkage-specification
template-declaration:

asm-declaration:

__asm( string-literal );

decl-specifiers:

decl-specifiers_opt decl-specifier

decl-specifier:

storage-class-specifier
type-specifier
fct-specifier
friend
typedef
__declspec ( extended-decl-modifier-seq )

storage-class-specifier:

auto
register
static
extern

fct-specifier:

inline
virtual

type-specifier:

simple-type-name
class-specifier
enum-specifier
elaborated-type-specifier
const
volatile

extended-decl-modifier-seq:

extended-decl-modifier_opt
extended-decl-modifier extended-decl-modifier-seq

extended-decl-modifier:

align(#)
allocate("segname")
dllimport
dllexport
nake
noinline
noreturn
nothrow
novtable
property({get=get_func_name|, put=put_func_name})
selectany
thread
uuid("ComObjectGUID")

simple-type-name:

complete-class-name
qualified-type-name
char
short
int
long
signed
unsigned
float
double
void

elaborated-type-specifier:

class-key identifier
class-key class-name
enum-name

class-key:

class
struct
union

qualified-type-name:

typedef-name
class-name :: qualified-type-name

complete-class-name:

qualified-class-name
:: qualified-class-name

qualified-class-name:

class-name
class-name :: qualified-class-name

enum-specifier:

enum identifier_opt { enum-list_opt }

enum-list:

enumerator
enum-list , enumerator

enumerator:

identifier
identifier = constant-expression

constant-expression:

conditional-expression

linkage-specification:

extern string-literal { declaration-list_opt }
extern string-literal declaration

declaration-list:

declaration
declaration-list declaration

template-declaration:

template < template-argument-list > declaration

template-argument-list:

template-argument
template-argument-list , template-argument

template-argument:

type-argument
argument-declaration

type-argument:

class identifier

template-class-name:

template-name < template-arg-list >

template-arg-list:

template-arg
template-arg-list , template-arg

template-arg:

expression
type-name

original-namespace-name :

identifier

namespace-definition :

original-namespace-definition
extension-namespace-definition
unnamed-namespace-definition

original-namespace-definition :

namespace identifier { namespace-body }

extension-namespace-definition :

namespace original-namespace-name { namespace-body }

unnamed-namespace-definition :

namespace { namespace-body }

namespace-body :

declaration-seq_opt

id-expression :

unqualified-id
qualified-id

nested-name-specifier :

class-or-namespace-name :: nested-name-specifier_opt

class-or-namespace-name :

class-name
namespace-name

namespace-name :

original-namespace-name
namespace-alias

namespace-alias :

identifier

namespace-alias-definition :

namespace identifier = qualified-namespace-specifier;

qualified-namespace-specifier :

::_opt nested-name-specifieropt class-or-namespace-name

using-declaration :

using ::_opt nested-name-specifier unqualified-id
using :: unqualified-id

using-directive :

using namespace ::_opt nested-name-specifier_opt namespace-name

---

declarator-list:

init-declarator
declarator-list ,   init-declarator

init-declarator:

ms-modifier-list_opt declarator initializer_opt

declarator:

dname
ptr-operator declarator
declarator ( argument-declaration-list ) cv-mod-list_opt
declarator [ constant-expression_opt ]
( declarator )

cv-mod-list:

cv-qualifier cv-mod-list_opt

ptr-operator:

ms-modifier-list_opt * cv-qualifier-list_opt
ms-modifier-list_opt & cv-qualifier-list_opt
ms-modifier-list_opt complete-class-name :: * cv-qualifier-list_opt

cv-qualifier-list:

cv-qualifier cv-qualifier-list_opt

cv-qualifier:

const
volatile

dname:

name
class-name
~ class-name
typedef-name
qualified-type-name

type-name:

type-specifier-list ms-modifier-list_opt abstract-declarator_opt

type-specifier-list:

type-specifier type-specifier-list_opt

abstract-declarator:

ptr-operator ms-modifier-list_opt abstract-declarator_opt
abstract-declarator_opt ( argument-declaration-list ) cv-qualifier-list_opt
abstract-declarator_opt [ constant-expression_opt ]
( ms-modifier-list_opt abstract-declarator )

argument-declaration-list:

arg-declaration-list_opt . . ._opt
arg-declaration-list , . . .

arg-declaration-list:

argument-declaration
arg-declaration-list , argument-declaration

argument-declaration:

decl-specifiers ms-modifier-list_opt declarator
decl-specifiers ms-modifier-list_opt declarator = expression
decl-specifiers ms-modifier-list_opt abstract-declarator_opt
decl-specifiers ms-modifier-list_opt abstract-declarator_opt = expression

function-definition:

decl-specifiers_opt ms-modifier-list_opt declarator ctor-initializer_opt fct-body

fct-body:

compound-statement

initializer:

= expression
= { initializer-list ,_opt }
( expression-list )

initializer-list:

expression
initializer-list , expression
{ initializer-list ,_opt }

---

class-specifier:

class-head { member-list_opt }

class-head:

class-key ambient-model_opt identifier_opt base-spec_opt
class-key ambient-model_opt class-name base-spec_opt

member-list:

member-declaration member-list_opt
access-specifier : member-list_opt

member-declaration:

decl-specifiers_opt member-declarator-list_opt ;
function-definition ;_opt
qualified-name ;

member-declarator-list:

member-declarator
member-declarator-list , member-declarator

member-declarator:

ms-modifier-list_opt declarator pure-specifier_opt
identifier_opt : constant-expression

pure-specifier:

= 0

base-spec:

: base-list

base-list:

base-specifier
base-list ,   base-specifier

base-specifier:

complete-class-name
virtual access-specifier_opt complete-class-name
access-specifier virtual_opt complete-class-name

access-specifier:

private
protected
public

conversion-function-name:

operator conversion-type-name

conversion-type-name:

type-specifier-list ptr-operator_opt

ctor-initializer:

: mem-initializer-list

mem-initializer-list:

mem-initializer
mem-initializer , mem-initializer-list

mem-initializer:

complete-class-name ( expression-list_opt )
identifier ( expression-list_opt )

operator-function-name:

operator operator

operator: one of

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

---

statement:

labeled-statement
expression-statement
compound-statement
selection-statement
iteration-statement
jump-statement
declaration-statement
asm-statement
try-except-statement
try-finally-statement

labeled-statement:

identifier : statement
case constant-expression : statement
default : statement

expression-statement:

expression_opt ;

compound-statement:

{ statement-list_opt }

statement-list:

statement
statement-list statement

selection-statement:

if ( expression ) statement
if ( expression ) statement else statement
switch ( expression ) statement

iteration-statement:

while ( expression ) statement
do statement while ( expression ) ;
for ( for-init-statement expression_opt ; expression_opt ) statement

for-init-statement:

expression-statement
declaration-statement

jump-statement:

break ;
continue ;
return expression_opt ;
goto identifier ;

declaration-statement:

declaration

try-except-statement:

__try compound-statement
__except ( expression ) compound-statement

try-finally-statement:

__try compound-statement
__finally ( expression ) compound-statement

---

asm-statement:

__asm assembly-instruction ;_opt
__asm { assembly-instruction-list } ;_opt

assembly-instruction-list:

assembly-instruction ;_opt
assembly-instruction ; assembly-instruction-list ;_opt

ms-modifier-list:

ms-modifier ms-modifier-list_opt

ms-modifier:

__cdecl
__fastcall
__stdcall
__syscall (reserved for future implementations)
__oldcall (reserved for future implementations)
__unaligned (reserved for future implementations)
based-modifier

based-modifier:

__based ( based-type )

based-type:

name