C# Grammar

Top level symbols:

input
compilation-unit

1 Lexical grammar

	( input-element )* new-line
\|	pp-directive

input-element ::=

whitespace | comment | token

1.1 Line terminators

new-line ::=

	Carriage_return_character_(U+000D)
\|	Line_feed_character_(U+000A)
\|	Carriage_return_character_(U+000D) Line_feed_character_(U+000A)
\|	Line_separator_character_(U+2028)
\|	Paragraph_separator_character_(U+2029)

1.2 White space

whitespace ::=

	Any_character_with_Unicode class_Zs
\|	Horizontal_tab_character_(U+0009)
\|	Vertical_tab_character_(U+000B)
\|	Form_feed_character_(U+000C)

1.3 Comments

comment ::=

	single-line-comment
\|	delimited-comment

single-line-comment ::=

// ( input-character )*

input-character ::=

Any_Unicode_character_except_a new-line-character

new-line-character ::=

	Carriage_return_character_(U+000D)
\|	Line_feed_character_(U+000A)
\|	Line_separator_character_(U+2028)
\|	Paragraph_separator_character_(U+2029)

delimited-comment ::=

/* ( delimited-comment-character )* */

delimited-comment-character ::=

	not-asterisk
\|	* not-slash

not-asterisk ::=

Any_Unicode_character_except_star_(*)

not-slash ::=

Any_Unicode_character_except_slash_(/)

1.4 Tokens

token ::=

	identifier
\|	keyword
\|	integer-literal
\|	real-literal
\|	character-literal
\|	string-literal
\|	operator-or-punctuator

1.5 Unicode characterescape sequences

unicode-character-escape-sequence ::=

	\u hex-digit hex-digit hex-digit hex-digit
\|	\U hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit

1.6 Identifiers

identifier ::=

	available-identifier
\|	@ identifier-or-keyword

available-identifier ::=

An identifier-or-keyword that_is_not_a keyword

identifier-or-keyword ::=

( identifier-start-character ( identifier-part-character )+ )?

identifier-start-character ::=

	letter-character
\|	The_underscore_character_(_)

identifier-part-character ::=

	letter-character
\|	decimal-digit-character
\|	connecting-character
\|	combining-character
\|	formatting-character

letter-character ::=

	A_Unicode_character_of_classes_Lu,_Ll,_Lt,_Lm,_Lo,_or_Nl
\|	A unicode-character-escape-sequence representing_a_character_of_classes_Lu,_Ll,_Lt,_Lm,_Lo,_or_Nl

combining-character ::=

	A_Unicode_character_of_classes_Mn_or_Mc
\|	A unicode-character-escape-sequence representing_a_character_of_classes_Mn_or_Mc

decimal-digit-character ::=

	A_Unicode_character_of_the_class_Nd
\|	A unicode-character-escape-sequence representing_a_character_of_the_class_Nd

connecting-character ::=

	A_Unicode_character_of_theclass_Pc
\|	A unicode-character-escape-sequence representing_a_character_of_the_class_Pc

formatting-character ::=

	A_Unicode_character_of_the_class_Cf
\|	A unicode-character-escape-sequence representing_a_character_of_the_class_Cf

1.7 Keywords

keyword ::=

1.8 Literals

literal ::=

	boolean-literal
\|	integer-literal
\|	real-literal
\|	character-literal
\|	string-literal
\|	null-literal

boolean-literal ::=

true | false

integer-literal ::=

	decimal-integer-literal
\|	hexadecimal-integer-literal

decimal-integer-literal ::=

( decimal-digit )+ ( integer-type-suffix )?

decimal-digit ::=

0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

integer-type-suffix ::=

U | u | L | l | UL | Ul | uL | ul | LU | Lu | lU | lu

hexadecimal-integer-literal ::=

	0x ( hex-digit )+ ( integer-type-suffix )?
\|	0X ( hex-digit )+ ( integer-type-suffix )?

hex-digit ::=

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

real-literal ::=

	( decimal-digit )* . ( decimal-digit )+ ( exponent-part )? ( real-type-suffix )?
\|	( decimal-digit )+ exponent-part ( real-type-suffix )?
\|	( decimal-digit )+ real-type-suffix

exponent-part ::=

	e ( sign )? ( decimal-digit )+
\|	E ( sign )? ( decimal-digit )+

sign ::=

+ | -

real-type-suffix ::=

F | f | D | d | M | m

character-literal ::=

' character '

character ::=

	single-character
\|	simple-escape-sequence
\|	hexadecimal-escape-sequence
\|	unicode-character-escape-sequence

single-character ::=

Any_character_except_'(U+0027),_\(U+005C),_and new-line-character

simple-escape-sequence ::=

\' | \" | \\ | \0 | \a | \b | \f | \n | \r | \t | \v

hexadecimal-escape-sequence ::=

\ x hex-digit ( hex-digit )? ( hex-digit )? ( hex-digit )?

string-literal ::=

	regular-string-literal
\|	verbatim-string-literal

regular-string-literal ::=

" ( regular-string-literal-character )* "

regular-string-literal-character ::=

	single-regular-string-literal-character
\|	simple-escape-sequence
\|	hexadecimal-escape-sequence
\|	unicode-character-escape-sequence

single-regular-string-literal-character ::=

Any_character_except_"(U+0022),_\(U+005C),_and new-line-character

verbatim-string-literal ::=

@" ( verbatim-string-literal-character )* "

verbatim-string-literal-character ::=

	single-verbatim-string-literal-character
\|	quote-escape-sequence

single-verbatim-string-literal-character ::=

Any_character_except "

quote-escape-sequence ::=

null-literal ::=

null

1.9 Operators andpunctuators

operator-or-punctuator ::=

{ | } | [ | ] | ( | ) | . | , | : | ; | + | - | * | / | % | & | | | ^ | ! | ~ | = | < | > | ? | ++ | -- | && | || | << | >> | == | != | <= | >= | += | -= | *= | /= | %= | &= | |= | ^= | <<= | >>= | ->

1.10 Pre-processing directives

pp-directive ::=

pp-declaration | pp-conditional | pp-line | pp-diagnostic | pp-region

pp-new-line ::=

( whitespace )? ( single-line-comment )? new-line

conditional-symbol ::=

Any identifier-or-keyword except_true_or_false

pp-expression ::=

( whitespace )? pp-or-expression ( whitespace )?

pp-or-expression ::=

	pp-and-expression
\|	pp-or-expression ( whitespace )? \|\| ( whitespace )? pp-and-expression

pp-and-expression ::=

	pp-equality-expression
\|	pp-and-expression ( whitespace )? && ( whitespace )? pp-equality-expression

pp-equality-expression ::=

	pp-unary-expression
\|	pp-equality-expression ( whitespace )? == ( whitespace )? pp-unary-expression
\|	pp-equality-expression ( whitespace )? != ( whitespace )? pp-unary-expression

pp-unary-expression ::=

	pp-primary-expression
\|	! ( whitespace )? pp-unary-expression

pp-primary-expression ::=

	true
\|	false
\|	conditional-symbol
\|	( ( whitespace )? pp-expression ( whitespace )? )

pp-declaration ::=

	( whitespace )? # ( whitespace )? define whitespace conditional-symbol pp-new-line
\|	( whitespace )? # ( whitespace )? undef whitespace conditional-symbol pp-new-line

pp-conditional ::=

pp-if-section ( pp-elif-section )* ( pp-else-section )? pp-endif

pp-if-section ::=

( whitespace )? # ( whitespace )? if whitespace pp-expression pp-new-line ( conditional-section )?

pp-elif-section ::=

( whitespace )? # ( whitespace )? elif whitespace pp-expression pp-new-line ( conditional-section )?

pp-else-section ::=

( whitespace )? # ( whitespace )? else pp-new-line ( conditional-section )?

pp-endif ::=

( whitespace )? # ( whitespace )? endif pp-new-line

conditional-section ::=

	( input-section-part )+
\|	( skipped-section-part )+

skipped-section-part ::=

	( skipped-characters )? new-line
\|	pp-directive

skipped-characters ::=

( whitespace )? not-number-sign ( input-character )*

not-number-sign ::=

Any input-character except_#

pp-line ::=

( whitespace )? # ( whitespace )? line ( whitespace )? line-indicator pp-new-line

line-indicator ::=

	( decimal-digit )+ whitespace file-name
\|	( decimal-digit )+
\|	default

file-name ::=

" ( file-name-character )+ "

file-name-character ::=

Any_character_except_"(U+0022),_and new-line

pp-diagnostic ::=

	( whitespace )? # ( whitespace )? error ( whitespace )? pp-message
\|	( whitespace )? # ( whitespace )? warning ( whitespace )? pp-message

pp-message ::=

( input-character )* new-line

pp-region ::=

pp-start-region ( conditional-section )? pp-end-region

pp-start-region ::=

( whitespace )? # ( whitespace )? region ( whitespace )? pp-message

pp-end-region ::=

( whitespace )? # ( whitespace )? endregion ( whitespace )? pp-message

2 Syntactic grammar

2.1 Basic concepts

namespace-name ::=

namespace-or-type-name

type-name ::=

namespace-or-type-name

namespace-or-type-name ::=

	identifier
\|	namespace-or-type-name . identifier

2.2 Types

type ::=

value-type | reference-type | pointer-type^a

value-type ::=

struct-type | enum-type

struct-type ::=

type-name | simple-type

simple-type ::=

numeric-type | bool

numeric-type ::=

	integral-type
\|	floating-point-type
\|	decimal

integral-type ::=

floating-point-type ::=

float | double

enum-type ::=

type-name

reference-type ::=

class-type | interface-type | array-type | delegate-type

class-type ::=

type-name | object | string

interface-type ::=

type-name

delegate-type ::=

type-name

2.3 Variables

variable-reference ::=

expression

2.4 Expressions

argument-list ::=

	argument
\|	argument-list , argument

argument ::=

	expression
\|	ref variable-reference
\|	out variable-reference

primary-expression ::=

	array-creation-expression
\|	primary-no-array-creation-expression

primary-no-array-creation-expression ::=

	literal
\|	simple-name
\|	parenthesized-expression
\|	member-access
\|	invocation-expression
\|	element-access
\|	this-access
\|	base-access
\|	post-increment-expression
\|	post-decrement-expression
\|	object-creation-expression
\|	delegate-creation-expression
\|	typeof-expression
\|	sizeof-expression
\|	checked-expression
\|	unchecked-expression
\|	pointer-member-access^a
\|	pointer-element-access^a
\|	sizeof-expression^a

simple-name ::=

identifier

parenthesized-expression ::=

( expression )

member-access ::=

	primary-expression . identifier
\|	predefined-type . identifier

predefined-type ::=

invocation-expression ::=

primary-expression ( ( argument-list )? )

element-access ::=

primary-no-array-creation-expression [ expression-list ]

expression-list ::=

	expression
\|	expression-list , expression

this-access ::=

this

base-access ::=

	base . identifier
\|	base [ expression-list ]

post-increment-expression ::=

primary-expression ++

post-decrement-expression ::=

primary-expression --

object-creation-expression ::=

new type ( ( argument-list )? )

array-creation-expression ::=

	new non-array-type [ expression-list ] ( rank-specifier )* ( array-initializer )?
\|	new array-type array-initializer

delegate-creation-expression ::=

new delegate-type ( expression )

typeof-expression ::=

	typeof ( type )
\|	typeof ( void )

checked-expression ::=

checked ( expression )

unchecked-expression ::=

unchecked ( expression )

unary-expression ::=

	primary-expression
\|	+ unary-expression
\|	- unary-expression
\|	! unary-expression
\|	~ unary-expression
\|	* unary-expression
\|	pre-increment-expression
\|	pre-decrement-expression
\|	cast-expression
\|	pointer-indirection-expression^a
\|	addressof-expression^a

pre-increment-expression ::=

++ unary-expression

pre-decrement-expression ::=

-- unary-expression

cast-expression ::=

( type ) unary-expression

multiplicative-expression ::=

	unary-expression
\|	multiplicative-expression * unary-expression
\|	multiplicative-expression / unary-expression
\|	multiplicative-expression % unary-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
\|	relational-expression is type
\|	relational-expression as type

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

conditional-and-expression ::=

	inclusive-or-expression
\|	conditional-and-expression && inclusive-or-expression

conditional-or-expression ::=

	conditional-and-expression
\|	conditional-or-expression \|\| conditional-and-expression

conditional-expression ::=

	conditional-or-expression
\|	conditional-or-expression ? expression : expression

assignment ::=

unary-expression assignment-operator expression

assignment-operator ::=

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

expression ::=

	conditional-expression
\|	assignment

constant-expression ::=

expression

boolean-expression ::=

expression

2.5 Statements

statement ::=

	labeled-statement
\|	declaration-statement
\|	embedded-statement

embedded-statement ::=

	block
\|	empty-statement
\|	expression-statement
\|	selection-statement
\|	iteration-statement
\|	jump-statement
\|	try-statement
\|	checked-statement
\|	unchecked-statement
\|	lock-statement
\|	using-statement
\|	unsafe-statement^b
\|	fixed-statement^c

block ::=

{ ( statement )* }

empty-statement ::=

;

labeled-statement ::=

identifier : statement

declaration-statement ::=

	local-variable-declaration ;
\|	local-constant-declaration ;

local-variable-declaration ::=

type local-variable-declarators

local-variable-declarators ::=

	local-variable-declarator
\|	local-variable-declarators , local-variable-declarator

local-variable-declarator ::=

	identifier
\|	identifier = local-variable-initializer

local-variable-initializer ::=

	expression
\|	array-initializer

local-constant-declaration ::=

const type constant-declarators

constant-declarators ::=

	constant-declarator
\|	constant-declarators , constant-declarator

constant-declarator ::=

identifier = constant-expression

expression-statement ::=

statement-expression ;

statement-expression ::=

	invocation-expression
\|	object-creation-expression
\|	assignment
\|	post-increment-expression
\|	post-decrement-expression
\|	pre-increment-expression
\|	pre-decrement-expression

selection-statement ::=

	if-statement
\|	switch-statement

if-statement ::=

	if ( boolean-expression ) embedded-statement
\|	if ( boolean-expression ) embedded-statement else embedded-statement

switch-statement ::=

switch ( expression ) switch-block

switch-block ::=

{ ( switch-section )* }

switch-section ::=

( switch-label )+ ( statement )+

switch-label ::=

	case constant-expression :
\|	default :

iteration-statement ::=

	while-statement
\|	do-statement
\|	for-statement
\|	foreach-statement

while-statement ::=

while ( boolean-expression ) embedded-statement

do-statement ::=

do embedded-statement while ( boolean-expression ) ;

for-statement ::=

for ( ( for-initializer )? ; ( for-condition )? ; ( for-iterator )? ) embedded-statement

for-initializer ::=

	local-variable-declaration
\|	statement-expression-list

for-condition ::=

boolean-expression

for-iterator ::=

statement-expression-list

statement-expression-list ::=

	statement-expression
\|	statement-expression-list , statement-expression

foreach-statement ::=

foreach ( type identifier in expression ) embedded-statement

jump-statement ::=

	break-statement
\|	continue-statement
\|	goto-statement
\|	return-statement
\|	throw-statement

break-statement ::=

break ;

continue-statement ::=

continue ;

goto-statement ::=

	goto identifier ;
\|	goto case constant-expression ;
\|	goto default ;

return-statement ::=

return ( expression )? ;

throw-statement ::=

throw ( expression )? ;

try-statement ::=

	try block catch-clauses
\|	try block finally-clause
\|	try block catch-clauses finally-clause

catch-clauses ::=

	( specific-catch-clause )+ ( general-catch-clause )?
\|	( specific-catch-clause )* general-catch-clause

specific-catch-clause ::=

catch ( class-type ( identifier )? ) block

general-catch-clause ::=

catch block

finally-clause ::=

finally block

checked-statement ::=

checked block

unchecked-statement ::=

unchecked block

lock-statement ::=

lock ( expression ) embedded-statement

using-statement ::=

using ( resource-acquisition ) embedded-statement

resource-acquisition ::=

	local-variable-declaration
\|	expression

compilation-unit ::=

( using-directive )* ( global-attribute-section )* ( namespace-member-declaration )*

namespace-declaration ::=

namespace qualified-identifier namespace-body ( ; )?

qualified-identifier ::=

	identifier
\|	qualified-identifier . identifier

namespace-body ::=

{ ( using-directive )* ( namespace-member-declaration )* }

using-directive ::=

	using-alias-directive
\|	using-namespace-directive

using-alias-directive ::=

using identifier = namespace-or-type-name ;

using-namespace-directive ::=

using namespace-name ;

namespace-member-declaration ::=

	namespace-declaration
\|	type-declaration

type-declaration ::=

	class-declaration
\|	struct-declaration
\|	interface-declaration
\|	enum-declaration
\|	delegate-declaration

2.6 Classes

class-declaration ::=

( attribute-section )* ( class-modifier )* class identifier ( class-base )? class-body ( ; )?

class-modifier ::=

class-base ::=

	: class-type
\|	: interface-type-list
\|	: class-type , interface-type-list

interface-type-list ::=

	interface-type
\|	interface-type-list , interface-type

class-body ::=

{ ( class-member-declaration )* }

class-member-declaration ::=

	constant-declaration
\|	field-declaration
\|	method-declaration
\|	property-declaration
\|	event-declaration
\|	indexer-declaration
\|	operator-declaration
\|	constructor-declaration
\|	destructor-declaration
\|	static-constructor-declaration
\|	type-declaration

constant-declaration ::=

( attribute-section )* ( constant-modifier )* const type constant-declarators ;

constant-modifier ::=

new | public | protected | internal | private

field-declaration ::=

( attribute-section )* ( field-modifier )* type variable-declarators ;

field-modifier ::=

variable-declarators ::=

	variable-declarator
\|	variable-declarators , variable-declarator

variable-declarator ::=

	identifier
\|	identifier = variable-initializer

variable-initializer ::=

	expression
\|	array-initializer
\|	stackalloc-initializer^a

method-declaration ::=

method-header method-body

method-header ::=

( attribute-section )* ( method-modifier )* return-type member-name ( ( formal-parameter-list )? )

method-modifier ::=

return-type ::=

type | void

member-name ::=

	identifier
\|	interface-type . identifier

method-body ::=

block | ;

formal-parameter-list ::=

	fixed-parameters
\|	fixed-parameters , parameter-array
\|	parameter-array

fixed-parameters ::=

	fixed-parameter
\|	fixed-parameters , fixed-parameter

fixed-parameter ::=

( attribute-section )* ( parameter-modifier )? type identifier

parameter-modifier ::=

ref | out

parameter-array ::=

( attribute-section )* params array-type identifier

property-declaration ::=

( attribute-section )* ( property-modifier )* type member-name { accessor-declarations }

property-modifier ::=

accessor-declarations ::=

	get-accessor-declaration ( set-accessor-declaration )?
\|	set-accessor-declaration ( get-accessor-declaration )?

get-accessor-declaration ::=

( attribute-section )* get accessor-body

set-accessor-declaration ::=

( attribute-section )* set accessor-body

accessor-body ::=

block | ;

event-declaration ::=

	( attribute-section )* ( event-modifier )* event type variable-declarators ;
\|	( attribute-section )* ( event-modifier )* event type member-name { event-accessor-declarations }

event-modifier ::=

event-accessor-declarations ::=

	add-accessor-declaration remove-accessor-declaration
\|	remove-accessor-declaration add-accessor-declaration

add-accessor-declaration ::=

( attribute-section )* add block

remove-accessor-declaration ::=

( attribute-section )* remove block

indexer-declaration ::=

( attribute-section )* ( indexer-modifier )* indexer-declarator { accessor-declarations }

indexer-modifier ::=

indexer-declarator ::=

	type this [ formal-parameter-list ]
\|	type interface-type . this [ formal-parameter-list ]

operator-declaration ::=

( attribute-section )* ( operator-modifier )+ operator-declarator operator-body

operator-modifier ::=

public | static | extern

operator-declarator ::=

	unary-operator-declarator
\|	binary-operator-declarator
\|	conversion-operator-declarator

unary-operator-declarator ::=

type operator overloadable-unary-operator ( type identifier )

overloadable-unary-operator ::=

+ | - | ! | ~ | ++ | -- | true | false

binary-operator-declarator ::=

type operator overloadable-binary-operator ( type identifier , type identifier )

overloadable-binary-operator ::=

+ | - | * | / | % | & | | | ^ | << | >> | == | != | > | < | >= | <=

conversion-operator-declarator ::=

	implicit operator type ( type identifier )
\|	explicit operator type ( type identifier )

operator-body ::=

block | ;

constructor-declaration ::=

( attribute-section )* ( constructor-modifier )* constructor-declarator constructor-body

constructor-modifier ::=

public | protected | internal | private | extern

constructor-declarator ::=

identifier ( ( formal-parameter-list )? ) ( constructor-initializer )?

constructor-initializer ::=

	: base ( ( argument-list )? )
\|	: this ( ( argument-list )? )

constructor-body ::=

block | ;

static-constructor-declaration ::=

( attribute-section )* static-constructor-modifiers identifier ( ) static-constructor-body

static-constructor-modifiers ::=

	( extern )? static
\|	static ( extern )?

static-constructor-body ::=

block | ;

destructor-declaration ::=

( attribute-section )* ( extern )? ~ identifier ( ) destructor-body

destructor-body ::=

block | ;

2.7 Structs

struct-declaration ::=

( attribute-section )* ( struct-modifier )* struct identifier ( struct-interfaces )? struct-body ( ; )?

struct-modifier ::=

new | public | protected | internal | private

struct-interfaces ::=

: interface-type-list

struct-body ::=

{ ( struct-member-declaration )* }

struct-member-declaration ::=

	constant-declaration
\|	field-declaration
\|	method-declaration
\|	property-declaration
\|	event-declaration
\|	indexer-declaration
\|	operator-declaration
\|	constructor-declaration
\|	static-constructor-declaration
\|	type-declaration

2.8 Arrays

array-type ::=

non-array-type ( rank-specifier )+

non-array-type ::=

type

rank-specifier ::=

[ ( dim-separators )? ]

dim-separators ::=

	,
\|	dim-separators ,

array-initializer ::=

	{ ( variable-initializer-list )? }
\|	{ variable-initializer-list , }

variable-initializer-list ::=

	variable-initializer
\|	variable-initializer-list , variable-initializer

2.9 Interfaces

interface-declaration ::=

( attribute-section )* ( interface-modifier )* interface identifier ( interface-base )? interface-body ( ; )?

interface-modifier ::=

new | public | protected | internal | private

interface-base ::=

: interface-type-list

interface-body ::=

{ ( interface-member-declaration )* }

interface-member-declaration ::=

	interface-method-declaration
\|	interface-property-declaration
\|	interface-event-declaration
\|	interface-indexer-declaration

interface-method-declaration ::=

( attribute-section )* ( new )? return-type identifier ( ( formal-parameter-list )? ) ;

interface-property-declaration ::=

( attribute-section )* ( new )? type identifier { interface-accessors }

interface-accessors ::=

	( attribute-section )* get ;
\|	( attribute-section )* set ;
\|	( attribute-section )* get ; ( attribute-section )* set ;
\|	( attribute-section )* set ; ( attribute-section )* get ;

interface-event-declaration ::=

( attribute-section )* ( new )? event type identifier ;

interface-indexer-declaration ::=

( attribute-section )* ( new )? type this [ formal-parameter-list ] { interface-accessors }

2.10 Enums

enum-declaration ::=

( attribute-section )* ( enum-modifier )* enum identifier ( enum-base )? enum-body ( ; )?

enum-base ::=

: integral-type

enum-body ::=

	{ ( enum-member-declarations )? }
\|	{ enum-member-declarations , }

enum-modifier ::=

new | public | protected | internal | private

enum-member-declarations ::=

	enum-member-declaration
\|	enum-member-declarations , enum-member-declaration

enum-member-declaration ::=

	( attribute-section )* identifier
\|	( attribute-section )* identifier = constant-expression

2.11 Delegates

delegate-declaration ::=

( attribute-section )* ( delegate-modifier )* delegate return-type identifier ( ( formal-parameter-list )? ) ;

delegate-modifier ::=

new | public | protected | internal | private

2.12 Attributes

global-attribute-section ::=

	[ global-attribute-target-specifier attribute-list ]
\|	[ global-attribute-target-specifier attribute-list , ]

global-attribute-target-specifier ::=

global-attribute-target :

global-attribute-target ::=

assembly

attribute-section ::=

	[ ( attribute-target-specifier )? attribute-list ]
\|	[ ( attribute-target-specifier )? attribute-list , ]

attribute-target-specifier ::=

attribute-target :

attribute-target ::=

attribute-list ::=

	attribute
\|	attribute-list , attribute

attribute ::=

attribute-name ( attribute-arguments )?

attribute-name ::=

type-name

attribute-arguments ::=

	( ( positional-argument-list )? )
\|	( positional-argument-list , named-argument-list )
\|	( named-argument-list )

positional-argument-list ::=

	positional-argument
\|	positional-argument-list , positional-argument

positional-argument ::=

attribute-argument-expression

named-argument-list ::=

	named-argument
\|	named-argument-list , named-argument

named-argument ::=

identifier = attribute-argument-expression

attribute-argument-expression ::=

expression

3 Grammar extensions for unsafe code

unsafe-statement ::=

unsafe block

pointer-type ::=

	unmanaged-type *
\|	void *

unmanaged-type ::=

type

pointer-indirection-expression ::=

* unary-expression

pointer-member-access ::=

primary-expression - > identifier

pointer-element-access ::=

primary-no-array-creation-expression [ expression ]

addressof-expression ::=

& unary-expression

sizeof-expression ::=

sizeof ( unmanaged-type )

fixed-statement ::=

fixed ( pointer-type fixed-pointer-declarators ) embedded-statement

fixed-pointer-declarators ::=

	fixed-pointer-declarator
\|	fixed-pointer-declarators , fixed-pointer-declarator

fixed-pointer-declarator ::=

identifier = fixed-pointer-initializer

fixed-pointer-initializer ::=

	& variable-reference
\|	expression

stackalloc-initializer ::=

stackalloc unmanaged-type [ expression ]

Notes:

a) Available in an unsafe context.

b) Starts unsafe statement.

c) Declares unsafe pointer.

Created from ECMA-334 Standard. Text form of the grammar was brushed a little (this was partially manual work and a probable source of errors if there are any :o( ), parsed to generate the grammar description in an XML format, transformed to EBNF using XSLT, then transformed to DHTML using another XSLT. Enjoy.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You can receive a copy of the GNU General Public License here.