Annex A (informative)
Grammar summary

Version WP-AM-002, Copyright(C) 8, Aug 1997 by the Embedded C++ Technical Committee

This summary of C++ syntax is intended to be an aid to comprehension. It is not an exact statement of the language. In particular, the grammar described here accepts a superset of valid C++ constructs. Disambiguation rules (6.8, 7.1, 10.2) must be applied to distinguish expressions from declarations. Further, access control, ambiguity, and type rules must be used to weed out syntactically valid but meaningless constructs.
Explanatory Notes for EC++:
The line displayed in green is deleted for EC++.
Example:

dynamic_cast < type-id > ( expression )

This means "dynamic_cast < type-id > ( expression )" is deleted for EC++.
The word displayed in blue is reduced by NULL for EC++.
Example:

nested-name-specifier template_opt unqualified-id

This means "template_opt" is reduced by NULL.

A.1 Keywords
New context-dependent keywords are introduced into a program by typedef (7.1.3), namespace (7.3.1), class (9), enumeration (7.2), and template (14) declarations.

typedef-name:: identifier

namespace-name:: original-namespace-name; namespace-alias

original-namespace-name:: identifier

namespace-alias:: identifier

class-name:: identifier
template-id

enum-name:: identifier

template-name:: identifier

Note that a typedef-name naming a class is also a class-name (9.1).

A.2 Lexical conventions

hex-quad:

hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit

universal-character-name:

\u hex-quad

\U hex-quad hex-quad

preprocessing-token:

header-name

identifier

pp-number

character-literal

string-literal

preprocessing-op-or-punc

each non-white-space character that cannot be one of the above

token:

identifier

keyword

literal

operator

punctuator

header-name:

<h-char-sequence>

"q-char-sequence"

h-char-sequence:

h-char

h-char-sequence h-char

h-char:

any member of the source character set except: new-line and >

q-char-sequence:

q-char

q-char-sequence q-char

q-char:

any member of the source character set except: new-line and "

pp-number:

digit

. digit

pp-number digit

pp-number nondigit

pp-number e sign

pp-number E sign

pp-number .

identifier:

nondigit

identifier nondigit

identifier digit

universal-character-name

nondigit: one of

universal-character-name

digit: one of: 0 1 2 3 4 5 6 7 8 9

preprocessing-op-or-punc: one of
{	}	[	]	#	##	(	)
<:	:>	<%	%>	%:	%:%:	;	:	...
new	delete	?	::	.	.*
+	-	*	/	%	^	&	\|	~
!	=	<	>	+=	-=	*=	/=	%=
^=	&=	\|=	<<	>>	>>=	<<=	==	!=
<=	>=	&&	\| \|	++	--	,	->*	->
and	and_eq	bitand	bitor	compl	not	not_eq	or	or_eq
xor	xor_eq

literal:: integer-literal; character-literal; floating-literal; string-literal; boolean-literal

integer-literal:: decimal-literal integer-suffix_opt; octal-literal integer-suffix_opt; hexadecimal-literal integer-suffix_opt

decimal-literal:: nonzero-digit; decimal-literal digit

octal-literal:: 0; octal-literal octal-digit

hexadecimal-literal:: 0x hexadecimal-digit; 0X hexadecimal-digit; hexadecimal-literal 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-literal:: ' 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 new-line character

escape-sequence

universal-character-name

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:: \x hexadecimal-digit; hexadecimal-escape-sequence hexadecimal-digit

floating-literal:: fractional-constant exponent-part_optfloating-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: the double-quote ", backslash \, or new-line character

escape-sequence

universal-character-name

boolean-literal:: false; true

A.3 Basic concepts

translation unit:: declaration-seq_opt

A.4 Expressions

primary-expression:: literal; this; :: identifier; :: operator-function-id; :: qualified-id; ( expression ); id-expression

id-expression:: unqualified-id; qualified-id

unqualified-id:: identifier; operator-function-id; conversion-function-id; ~ class-name; template-id

qualified-id:: nested-name-specifier template_opt unqualified-id

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

class-or-namespace-name:: class-name; namespace-name

postfix-expression:: primary-expression; postfix-expression [ expression ]; postfix-expression ( expression-list_opt ); simple-type-specifier ( expression-list_opt ); postfix-expression . template_opt ::_opt id-expression; postfix-expression -> template_opt ::_opt id-expression; postfix-expression . pseudo-destructor-name; postfix-expression -> pseudo-destructor-name; 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 )

expression-list:: assignment-expression; expression-list , assignment-expression

pseudo-destructor-name:: ::_opt nested-name-specifier_opt type-name :: ~ type-name; ::_opt nested-name-specifier_opt~ type-name

unary-expression:: postfix-expression; ++ cast-expression; -- cast-expression; unary-operator cast-expression; sizeof unary-expression; sizeof ( type-id ); new-expression; delete-expression

unary-operator: one of: * & + - ! ~

new-expression:: :: _opt new new-placement_opt new-type-id new-initializer_opt; :: _opt new new-placement_opt ( type-id ) new-initializer_opt

new-placement:: ( expression-list )

new-type-id:: type-specifier-seq new-declarator_opt

new-declarator:: ptr-operator new-declarator_opt; direct-new-declarator

direct-new-declarator:: [ expression ]; direct-new-declarator [ constant-expression ]

new-initializer:: ( expression-list_opt )

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

cast-expression:: unary-expression; ( type-id ) cast-expression

pm-expression:: cast-expression; pm-expression .* cast-expression; pm-expression ->* cast-expression

multiplicative-expression:: pm-expression; multiplicative-expression * pm-expression; multiplicative-expression / pm-expression; multiplicative-expression % pm-expression

additive-expression:: multiplicative-expression; additive-expression + multiplicative-expression; additive-expression - multiplicative-expression

shift-expression:: additive-expression; shift-expression << additive-expression; shift-expression >> additive-expression

relational-expression:: shift-expression; relational-expression < shift-expression; relational-expression > shift-expression; relational-expression <= shift-expression; relational-expression >= shift-expression

equality-expression:: relational-expression; equality-expression == relational-expression; equality-expression != relational-expression

and-expression:: equality-expression; and-expression & equality-expression

exclusive-or-expression:: and-expression; exclusive-or-expression ^ and-expression

inclusive-or-expression:: exclusive-or-expression; inclusive-or-expression | exclusive-or-expression

logical-and-expression:: inclusive-or-expression; logical-and-expression && inclusive-or-expression

logical-or-expression:: logical-and-expression; logical-or-expression || logical-and-expression

conditional-expression:: logical-or-expression; logical-or-expression ? expression : assignment-expression

assignment-expression:: conditional-expression; logical-or-expression assignment-operator assignment-expression; throw-expression

assignment-operator: one of: = *= /= %= += -= >>= <<= &= ^= |=

expression:: assignment-expression; expression , assignment-expression

constant-expression:: conditional-expression

A.5 Statements

statement:: labeled-statement; expression-statement; compound-statement; selection-statement; iteration-statement; jump-statement; declaration-statement; try-block

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

expression-statement:: expression_opt ;

compound-statement:: { statement-seq_opt }

statement-seq:: statement; statement-seq statement

selection-statement:: if ( condition ) statement; if ( condition ) statement else statement; switch ( condition ) statement

condition:: expression; type-specifier-seq declarator = assignment-expression

iteration-statement:: while ( condition ) statement; do statement while ( expression ) ;; for ( for-init-statement condition_opt ; expression_opt ) statement

for-init-statement:: expression-statement; simple-declaration

jump-statement:: break ;; continue ;; return expression_opt ;; goto identifier ;

declaration-statement:: block-declaration

A.6 Declarations

declaration-seq:: declaration; declaration-seq declaration

declaration:: block-declaration; function-definition; template-declaration; explicit-instantiation; explicit-specialization; linkage-specification; namespace-definition

block-declaration:: simple-declaration; asm-definition; namespace-alias-definition; using-declaration; using-directive

simple-declaration:: decl-specifier-seq_opt init-declarator-list_opt ;

decl-specifier:: storage-class-specifier; type-specifier; function-specifier; friend; typedef

decl-specifier-seq:: decl-specifier-seq_opt decl-specifier

storage-class-specifier:: auto; register; static; extern; mutable

function-specifier:: inline; virtual; explicit

typedef-name:: identifier

type-specifier:: simple-type-specifier; class-specifier; enum-specifier; elaborated-type-specifier; cv-qualifier

simple-type-specifier:: ::_opt nested-name-specifier_opt type-name; char; wchar_t; bool; short; int; long; signed; unsigned; float; double; void

type-name:: class-name; enum-name; typedef-name

elaborated-type-specifier:: class-key ::_opt nested-name-specifier_opt identifier; enum ::_opt nested-name-specifier_opt identifier; typename ::_opt nested-name-specifier identifier; typename ::_opt nested-name-specifier identifier < template-argument-list >

enum-name:: identifier

enum-specifier:: enum identifier_opt { enumerator-list_opt }

enumerator-list:: enumerator-definition; enumerator-list , enumerator-definition

enumerator-definition:: enumerator; enumerator = constant-expression

enumerator:: identifier

namespace-name:: original-namespace-name; namespace-alias

original-namespace-name:: identifier

namespace-definition:: named-namespace-definition; unnamed-namespace-definition

named-namespace-definition:: original-namespace-definition; extension-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

namespace-alias:: identifier

namespace-alias-definition:: namespace identifier = qualified-namespace-specifier ;

qualified-namespace-specifier:: ::_opt nested-name-specifier_opt namespace-name

using-declaration:: using typename_opt ::_opt nested-name-specifier unqualified-id ;; using :: unqualified-id ;

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

asm-definition:: asm ( string-literal ) ;

linkage-specification:: extern string-literal { declaration-seq_opt }; extern string-literal declaration

A.7 Declarators

init-declarator-list:: init-declarator; init-declarator-list , init-declarator

init-declarator:: declarator initializer_opt

declarator:: direct-declarator; ptr-operator declarator

direct-declarator:: declarator-id; direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq_opt exception-specification_opt; direct-declarator [ constant-expression_opt ]
( declarator )

ptr-operator:: * cv-qualifier-seq_opt; &; ::_opt nested-name-specifier * cv-qualifier-seq_opt

cv-qualifier-seq:: cv-qualifier cv-qualifier-seq_opt

cv-qualifier:: const; volatile

declarator-id:: ::_opt id-expression; ::_opt nested-name-specifier_opt type-name

type-id:: type-specifier-seq abstract-declarator_opt

type-specifier-seq:: type-specifier type-specifier-seq_opt

abstract-declarator:: ptr-operator abstract-declarator_opt; direct-abstract-declarator

direct-abstract-declarator:: direct-abstract-declarator_opt ( parameter-declaration-clause ) cv-qualifier-seq_opt exception-specification_opt; direct-abstract-declarator_opt [ constant-expression_opt ]
( abstract-declarator )

parameter-declaration-clause:: parameter-declaration-list_opt ..._opt; parameter-declaration-list , ...

parameter-declaration-list:: parameter-declaration; parameter-declaration-list , parameter-declaration

parameter-declaration:: decl-specifier-seq declarator; decl-specifier-seq declarator = assignment-expression; decl-specifier-seq abstract-declarator_opt; decl-specifier-seq abstract-declarator_opt = assignment-expression

function-definition:: decl-specifier-seq_opt declarator ctor-initializer_opt function-body; decl-specifier-seq_opt declarator function-try-block

function-body:: compound-statement

initializer:: = initializer-clause; ( expression-list )

initializer-clause:: assignment-expression; { initializer-list ,_opt }; { }

initializer-list:: initializer-clause; initializer-list , initializer-clause

A.8 Classes

class-name:: identifier; template-id

class-specifier:: class-head { member-specification_opt }

class-head:: class-key identifier_opt base-clause_opt; class-key nested-name-specifier identifier base-clause_opt

class-key:: class; struct; union

member-specification:: member-declaration member-specification_opt; access-specifier : member-specification_opt

member-declaration:: decl-specifier-seq_opt member-declarator-list_opt ;; function-definition ;_opt; qualified-id ;; using-declaration; template-declaration

member-declarator-list:: member-declarator; member-declarator-list , member-declarator

member-declarator:: declarator pure-specifier_opt; declarator constant-initializer_opt; identifier_opt : constant-expression

pure-specifier:: = 0

constant-initializer:: = constant-expression

A.9 Derived classes

base-clause:: : base-specifier-list

base-specifier-list:: base-specifier; base-specifier-list , base-specifier

base-specifier:: ::_opt nested-name-specifier_opt class-name; virtual access-specifier_opt ::_opt nested-name-specifier_opt class-name; access-specifier virtual_opt ::_opt nested-name-specifier_opt class-name

access-specifier:: private; protected; public

A.10 Special member functions

conversion-function-id:: operator conversion-type-id

conversion-type-id:: type-specifier-seq conversion-declarator_opt

conversion-declarator:: ptr-operator conversion-declarator_opt

ctor-initializer:: : mem-initializer-list

mem-initializer-list:: mem-initializer; mem-initializer , mem-initializer-list

mem-initializer:: mem-initializer-id ( expression-list_opt )

mem-initializer-id:: ::_opt nested-name-specifier_opt class-name; identifier

A.11 Overloading

operator-function-id:

operator operator

operator:	one of
	new	delete		new[ ]			delete[ ]
	+	-	*	/	%	^	&	\|	~
	!	=	<	>	+=	-=	*=	/=	%=
	^=	&=	\|=	<<	>>	>>=	<<=	==	!=
	<=	>=	& &	\| \|	++	--	,	->*	->
	( )	[ ]

A.12 Templates

template-declaration:: export_opt template < template-parameter-list > declaration

template-parameter-list:: template-parameter; template-parameter-list ,template-parameter

template-parameter:: type-parameter; parameter-declaration

type-parameter:: class identifier_opt; class identifier_opt = type-id; typename identifier_opt; typename identifier_opt= type-id; template < template-parameter-list > class identifier_opt; template < template-parameter-list > class identifier_opt = template-name

template-id:: template-name <template-argument-list >

template-name:: identifier

template-argument-list:: template-argument; template-argument-list , template-argument

template-argument:: assignment-expression; type-id; template-name

explicit-instantiation:: template declaration

explicit- specialization:: template < > declaration

A.13 Exception handling

try-block:: try compound-statement handler-seq

function-try-block:: try ctor-initializer_opt function-body handler-seq

handler-seq:: handler handler-seq_opt

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

exception-declaration:: type-specifier-seq declarator; type-specifier-seq abstract-declarator; type-specifier-seq; ...

throw-expression:: throw assignment-expression_opt

exception-specification:: throw ( type-id-list_opt )

type-id-list:: type-id; type-id-list , type-id

A.14 Preprocessing directives

preprocessing-file:: group_opt

group:: group-part; group group-part

group-part:: pp-tokens_opt new-line; if-section; control-line

if-section:: if-group elif-groups_opt else-group_opt endif-line

if-group:: # if constant-expression new-line group_opt; # ifdef identifier new-line group_opt; # ifndef identifier new-line group_opt

elif-groups:: elif-group; elif-groups elif-group

elif-group:: # elif constant-expression new-line group_opt

else-group:: # else new-line group_opt

endif-line:: # endif new-line

control-line:: # include pp-tokens new-line; # define identifier replacement-list new-line; # define identifier lparen identifier-list_opt ) replacement-list new-line; # undef identifier new-line; # line pp-tokens new-line; # error pp-tokens_opt new-line; # pragma pp-tokens_opt new-line; # new-line

lparen:: the left-parenthesis character without preceding white-space

replacement-list:: pp-tokens_opt

pp-tokens:: preprocessing-token; pp-tokens preprocessing-token

new-line:: the new-line character

Annex A (informative) Grammar summary

Annex A (informative)
Grammar summary